public void CanGetRequestByRequestId()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request1 = CreateRequest();

            request1.Behavior.Tag = "A";

            Request request2 = CreateRequest();

            request2.Behavior.Tag = "B";

            Request request3 = CreateRequest();

            request3.Behavior.Tag = "A";

            queue.Enqueue(request1);
            queue.Enqueue(request2);
            queue.Enqueue(request3);

            Assert.AreEqual(3, queue.GetCount());

            Request req = queue.GetRequest(request2.RequestId);

            queue.Remove(req);

            Assert.IsNotNull(req);
            Assert.IsTrue(AreEqual(request2, req));
            Assert.AreEqual(2, queue.GetCount());
        }
        public void RequestsIteratorIsFifo()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request1 = CreateRequest();
            Request request2 = CreateRequest();
            Request request3 = CreateRequest();
            Request request4 = CreateRequest();

            queue.Enqueue(request1);
            queue.Enqueue(request2);
            queue.Enqueue(request3);
            queue.Enqueue(request4);

            Assert.AreEqual(4, queue.GetCount());

            List <Request> list = new List <Request>();

            foreach (Request req in queue.GetRequests())
            {
                list.Add(req);
                queue.Remove(req);
            }

            Assert.AreEqual(4, list.Count);
            Assert.IsTrue(AreEqual(request1, list[0]));
            Assert.IsTrue(AreEqual(request2, list[1]));
            Assert.IsTrue(AreEqual(request3, list[2]));
            Assert.IsTrue(AreEqual(request4, list[3]));
            Assert.AreEqual(0, queue.GetCount());
        }
        public void EnquequeThrowsWhenPassedRequestWithNullMethodName()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.MethodName = null;
            queue.Enqueue(request1);
        }
        public void EnquequeThrowsWhenPassedRequestWithNullOnlineProxyType()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.OnlineProxyType = null;
            queue.Enqueue(request1);
        }
        public void EnquequeThrowsWhenPassedRequestWithNullEndpoint()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.Endpoint = null;
            queue.Enqueue(request1);
        }
        public void EnquequeThrowsWhenPassedRequestWithBehaviorWithNullProxyFactoryType()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.Behavior.ProxyFactoryType = null;
            queue.Enqueue(request1);
        }
        public void EnquequeThrowsWhenPassedRequestWithNullBehavior()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.Behavior = null;
            queue.Enqueue(request1);
        }
        public void AddRequestIncreasesCount()
        {
            MemoryRequestQueue queue = new MemoryRequestQueue();
            int expected             = queue.GetCount() + 1;

            queue.Enqueue(CreateRequest());

            Assert.AreEqual(expected, queue.GetCount());
        }
        public void CannotEnquequeRequestsWithSameId()
        {
            Request request1 = CreateRequest();
            Request request2 = CreateRequest();

            request2.RequestId = request1.RequestId;

            IRequestQueue queue = new MemoryRequestQueue();

            queue.Enqueue(request1);
            queue.Enqueue(request2);
        }
        public void RemovingARequestsDecreasesCount()
        {
            IRequestQueue queue   = new MemoryRequestQueue();
            Request       request = CreateRequest();

            Assert.AreEqual(0, queue.GetCount());
            queue.Enqueue(request);
            Assert.AreEqual(1, queue.GetCount());

            queue.Remove(request);
            Assert.AreEqual(0, queue.GetCount());
        }
        public void EnqueingRequestWithMissingMethodNameThrows()
        {
            Request request = new Request();

            request.Endpoint        = "Endpoint";
            request.OnlineProxyType = typeof(MemoryRequestQueueFixture);
            request.Behavior        = new OfflineBehavior();

            IRequestQueue queue = new MemoryRequestQueue();

            queue.Enqueue(request);
        }
        public void RequestCanBeQueuedWhenOptionalPropertiesNotSet()
        {
            Request request = new Request();

            request.Endpoint                  = "Endpoint";
            request.MethodName                = "Method";
            request.OnlineProxyType           = typeof(MemoryRequestQueueFixture);
            request.Behavior                  = new OfflineBehavior();
            request.Behavior.ProxyFactoryType = typeof(object);

            MemoryRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());
            queue.Enqueue(request);
            Assert.AreEqual(1, queue.GetCount());
        }
        public void OnEnqueuedEventIsFiredWhenRequestIsEnqueued()
        {
            bool eventFired = false;

            IRequestQueue queue = new MemoryRequestQueue();

            queue.RequestEnqueued += delegate(object sender, RequestEnqueuedEventArgs args) { eventFired = true; };

            Assert.IsFalse(eventFired);
            Request request1 = CreateRequest();

            request1.Behavior.Stamps = 7;
            queue.Enqueue(request1);
            Assert.IsTrue(eventFired);
            Assert.AreEqual(1, queue.GetCount());
        }
        public void OnRequestEnqueuedTheQueuedDateIsFilledInTheRequestByTheQueue()
        {
            IRequestQueue queue    = new MemoryRequestQueue();
            Request       request1 = CreateRequest();

            request1.Behavior.QueuedDate = null;
            Assert.IsNull(request1.Behavior.QueuedDate);
            DateTime before = DateTime.Now;

            queue.Enqueue(request1);
            DateTime after = DateTime.Now;

            Assert.IsNotNull(request1.Behavior.QueuedDate);
            Assert.IsTrue(before <= request1.Behavior.QueuedDate);
            Assert.IsTrue(after >= request1.Behavior.QueuedDate);
        }
        public void GetNextRequestDoesntRemoveItFromQueue()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request = CreateRequest();

            queue.Enqueue(request);

            Assert.AreEqual(1, queue.GetCount());
            Request dequeued = queue.GetNextRequest();

            Assert.AreEqual(1, queue.GetCount());
            Assert.IsTrue(AreEqual(request, dequeued));
        }
        public void RequestsByPriceAreFifo()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request1 = CreateRequest();

            request1.Behavior.Stamps = 7;
            Request request2 = CreateRequest();

            request2.Behavior.Stamps = 6;
            Request request3 = CreateRequest();

            request3.Behavior.Stamps = 1;
            Request request4 = CreateRequest();

            request4.Behavior.Stamps = 5;

            queue.Enqueue(request1);
            queue.Enqueue(request2);
            queue.Enqueue(request3);
            queue.Enqueue(request4);

            Assert.AreEqual(4, queue.GetCount());

            List <Request> list = new List <Request>();

            foreach (Request req in queue.GetRequests(5))
            {
                list.Add(req);
                queue.Remove(req);
            }

            Assert.AreEqual(3, list.Count);
            Assert.IsTrue(AreEqual(request1, list[0]));
            Assert.IsTrue(AreEqual(request2, list[1]));
            Assert.IsTrue(AreEqual(request4, list[2]));
            Assert.AreEqual(1, queue.GetCount());
        }
        public void CanGetRequestsIteratorByPrice()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request1 = CreateRequest();

            request1.Behavior.Stamps = 8;

            Request request2 = CreateRequest();

            request2.Behavior.Stamps = 3;

            Request request3 = CreateRequest();

            request3.Behavior.Stamps = 5;

            queue.Enqueue(request1);
            queue.Enqueue(request2);
            queue.Enqueue(request3);

            Assert.AreEqual(3, queue.GetCount());

            List <Request> list = new List <Request>();

            foreach (Request req in queue.GetRequests(5))
            {
                list.Add(req);
                queue.Remove(req);
            }

            Assert.AreEqual(2, list.Count);
            Assert.IsTrue(AreEqual(request1, list[0]));
            Assert.IsTrue(AreEqual(request3, list[1]));
            Assert.AreEqual(1, queue.GetCount());
        }
        public void GetRequestByRequestIdReturnsNullIfRequestIdIsNotFound()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());

            Request request1 = CreateRequest();

            request1.Behavior.Tag = "A";

            Request request2 = CreateRequest();

            request2.Behavior.Tag = "B";

            queue.Enqueue(request1);
            queue.Enqueue(request2);

            Assert.AreEqual(2, queue.GetCount());

            Request req = queue.GetRequest(Guid.Empty);

            Assert.IsNull(req);
            Assert.AreEqual(2, queue.GetCount());
        }
        public void InitialQueueIsEmpty()
        {
            MemoryRequestQueue queue = new MemoryRequestQueue();

            Assert.AreEqual(0, queue.GetCount());
        }
        public void EnquequeThrowsWhenPassedNull()
        {
            IRequestQueue queue = new MemoryRequestQueue();

            queue.Enqueue(null);
        }