Пример #1
0
        public void TestPutRequest()
        {
            TcpInitiator initiator         = GetInitiator();
            IConnection  conn              = initiator.EnsureConnection();
            IChannel     namedCacheChannel = GetNamedCacheChannel(conn);
            string       key           = "testPutKey";
            string       value1        = "testPutValue1";
            string       value2        = "testPutValue2";
            object       previousValue = null;

            GetRequest getRequest = (GetRequest)namedCacheChannel.MessageFactory.CreateMessage(GetRequest.TYPE_ID);

            getRequest.Key = convToBinary.Convert(key);
            IResponse getResponse = namedCacheChannel.Send(getRequest).WaitForResponse(-1);

            if (!getResponse.IsFailure)
            {
                previousValue = convFromBinary.Convert(getResponse.Result);
            }

            PutRequest putRequest = (PutRequest)namedCacheChannel.MessageFactory.CreateMessage(PutRequest.TYPE_ID);

            putRequest.Key              = convToBinary.Convert(key);
            putRequest.Value            = convToBinary.Convert(value1);
            putRequest.IsReturnRequired = true;

            Stream stream = new MemoryStream();
            Codec  codec  = new Codec();

            codec.Encode(namedCacheChannel, putRequest, new DataWriter(stream));
            stream.Position = 0;
            PutRequest result = (PutRequest)codec.Decode(namedCacheChannel, new DataReader(stream));

            Assert.AreEqual(putRequest.ExpiryDelay, result.ExpiryDelay);
            Assert.AreEqual(putRequest.IsReturnRequired, result.IsReturnRequired);
            Assert.AreEqual(convToBinary.Convert(value1), result.Value);
            Assert.IsNull(putRequest.Key);
            putRequest = result; //necessary, since Key has been null-ed while testing serialization

            IResponse putResponse = namedCacheChannel.Send(putRequest).WaitForResponse(-1);

            Assert.AreEqual(putRequest.TypeId, PutRequest.TYPE_ID);
            Assert.IsInstanceOf(typeof(NamedCacheResponse), putResponse);
            Assert.AreEqual(namedCacheChannel.MessageFactory.Version, putRequest.ImplVersion);
            Assert.IsFalse(putResponse.IsFailure);
            Assert.AreEqual(putResponse.RequestId, putRequest.Id);
            Assert.AreEqual(0, putResponse.TypeId);
            if (putRequest.IsReturnRequired)
            {
                if (previousValue == null)
                {
                    Assert.IsNull(putResponse.Result);
                }
                else
                {
                    Assert.AreEqual(convToBinary.Convert(previousValue), putResponse.Result);
                }
            }

            putRequest                  = (PutRequest)namedCacheChannel.MessageFactory.CreateMessage(PutRequest.TYPE_ID);
            putRequest.Key              = convToBinary.Convert(key);
            putRequest.Value            = convToBinary.Convert(value2);
            putRequest.IsReturnRequired = true;

            putResponse = namedCacheChannel.Send(putRequest).WaitForResponse(-1);
            Assert.IsFalse(putResponse.IsFailure);
            Assert.AreEqual(putResponse.RequestId, putRequest.Id);
            Assert.AreEqual(0, putResponse.TypeId);
            if (putRequest.IsReturnRequired)
            {
                Assert.AreEqual(value1, convFromBinary.Convert(putResponse.Result));
            }

            conn.Close();
            initiator.Stop();
        }
Пример #2
0
        public void TestRemoveRequest()
        {
            TcpInitiator initiator         = GetInitiator();
            IConnection  conn              = initiator.EnsureConnection();
            IChannel     namedCacheChannel = GetNamedCacheChannel(conn);
            string       key   = "testRemoveKey";
            string       value = "testRemoveValue";

            ClearRequest clearRequest =
                (ClearRequest)namedCacheChannel.MessageFactory.CreateMessage(ClearRequest.TYPE_ID);
            IResponse clearResponse = namedCacheChannel.Send(clearRequest).WaitForResponse(-1);

            Assert.IsFalse(clearResponse.IsFailure);

            PutRequest putRequest =
                (PutRequest)namedCacheChannel.MessageFactory.CreateMessage(PutRequest.TYPE_ID);

            putRequest.Key              = convToBinary.Convert(key);
            putRequest.Value            = convToBinary.Convert(value);
            putRequest.IsReturnRequired = true;
            IResponse putResponse = namedCacheChannel.Send(putRequest).WaitForResponse(-1);

            Assert.IsFalse(putResponse.IsFailure);
            Assert.IsNull(convFromBinary.Convert(putResponse.Result));

            ContainsKeyRequest containsKeyRequest =
                (ContainsKeyRequest)namedCacheChannel.MessageFactory.CreateMessage(ContainsKeyRequest.TYPE_ID);

            containsKeyRequest.Key = convToBinary.Convert(key);
            IResponse containsKeyResponse = namedCacheChannel.Send(containsKeyRequest).WaitForResponse(-1);

            Assert.IsFalse(containsKeyResponse.IsFailure);
            Assert.IsTrue((bool)containsKeyResponse.Result);

            RemoveRequest removeRequest = (RemoveRequest)namedCacheChannel.MessageFactory.CreateMessage(RemoveRequest.TYPE_ID);

            removeRequest.Key = convToBinary.Convert(key);
            removeRequest.IsReturnRequired = true;
            IResponse removeResponse = namedCacheChannel.Send(removeRequest).WaitForResponse(-1);

            Stream stream = new MemoryStream();
            Codec  codec  = new Codec();

            codec.Encode(namedCacheChannel, removeRequest, new DataWriter(stream));
            stream.Position = 0;
            RemoveRequest result = (RemoveRequest)codec.Decode(namedCacheChannel, new DataReader(stream));

            Assert.AreEqual(result.IsReturnRequired, removeRequest.IsReturnRequired);
            Assert.AreEqual(result.Key, removeRequest.Key);

            Assert.AreEqual(removeRequest.TypeId, RemoveRequest.TYPE_ID);
            Assert.IsInstanceOf(typeof(NamedCacheResponse), removeResponse);
            Assert.AreEqual(removeResponse.TypeId, NamedCacheResponse.TYPE_ID);
            Assert.AreEqual(removeRequest.Id, removeResponse.RequestId);
            Assert.IsFalse(removeResponse.IsFailure);
            if (removeRequest.IsReturnRequired)
            {
                Assert.AreEqual(removeResponse.Result, convToBinary.Convert(value));
            }

            containsKeyRequest     = (ContainsKeyRequest)namedCacheChannel.MessageFactory.CreateMessage(ContainsKeyRequest.TYPE_ID);
            containsKeyRequest.Key = convToBinary.Convert(key);
            containsKeyResponse    = namedCacheChannel.Send(containsKeyRequest).WaitForResponse(-1);
            Assert.IsFalse(containsKeyResponse.IsFailure);
            Assert.IsFalse((bool)containsKeyResponse.Result);

            conn.Close();
            initiator.Stop();
        }