public void EnqueuedRequestsWithAutomaticDispatchStartedAreNotDispatchedIfThereIsNotConnection()
        {
            MockEndpointCatalog   catalog           = CreateEndpointCatalog();
            MockConnectionMonitor connectionMonitor = CreateConnectionManager();
            IRequestQueue         queue             = new MockRequestQueue();
            MockRequestQueue      deadletterQueue   = new MockRequestQueue();

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, connectionMonitor, catalog);

            connectionMonitor.MockChangeConnectionStatus(false);

            mgr.StartAutomaticDispatch();

            Request request = new Request();

            request.Endpoint           = "Endpoint";
            request.Behavior.MessageId = Guid.NewGuid();
            request.Behavior.Stamps    = 9;
            request.OnlineProxyType    = typeof(MockService);
            request.MethodName         = "DoWithNoParams";

            Assert.AreEqual(0, queue.GetCount());
            queue.Enqueue(request);
            mgr.Join(1000);
            mgr.StopAutomaticDispatch();
            Assert.AreEqual(1, queue.GetCount(), "The request should not be dispatched until connection is available.");
        }
        public void RequestsWithMissingEndpointAreMovedToTheDeadLetterQueue()
        {
            MockRequestDispatcher disp              = new MockRequestDispatcher();
            MockEndpointCatalog   endCatalog        = CreateEndpointCatalog();
            MockConnectionMonitor connectionMonitor = CreateConnectionManager();
            MockRequestQueue      requestQueue      = new MockRequestQueue();
            MockRequestQueue      deadLetterQueue   = new MockRequestQueue();

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(requestQueue, deadLetterQueue, connectionMonitor, endCatalog);

            Request r = new Request();

            r.Endpoint = "MissingEndpoint";
            mgr.RequestQueue.Enqueue(r);

            connectionMonitor.MockChangeConnectionStatus(true);
            mgr.DispatchRequest(r);
            mgr.Join(1000);
            Assert.AreEqual(0, disp.RequestsReceived.Count);
            Assert.AreEqual(1, deadLetterQueue.GetCount());
            Assert.AreEqual(0, requestQueue.GetCount());
            Assert.AreSame(r, deadLetterQueue.requests[0]);
        }
        public void IfRequestSucceedsRemoveFromQueue()
        {
            MockRequestQueue    queue           = new MockRequestQueue();
            MockEndpointCatalog endCatalog      = new MockEndpointCatalog();
            MockRequestQueue    deadletterQueue = new MockRequestQueue();

            endCatalog.Endpoints.Add("E1", new MockEndpoint("E1"));
            endCatalog.Endpoints["E1"].Default = new MockEndpointConfig("DefaultURI2");

            MockConnectionMonitor cm = new MockConnectionMonitor();

            cm.CurrentNetwork         = "net";
            cm.CurrentConnectionPrice = 5;
            cm.MockChangeConnectionStatus(true);

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
            MockRequestDispatcher disp = MockRequestDispatcher.Instance;

            Request r1 = new Request();

            r1.Endpoint        = "E1";
            r1.Behavior.Stamps = 9;

            disp.ForceFails = false;
            mgr.StartAutomaticDispatch();
            queue.Enqueue(r1);
            mgr.Join(1000);

            Assert.AreEqual(1, disp.RequestsReceived.Count);
            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.AreEqual(0, queue.GetCount());
        }
        public void DispatchRequestsForConnectionStatusChangeToConnected()
        {
            MockRequestQueue    queue           = new MockRequestQueue();
            MockRequestQueue    deadletterQueue = new MockRequestQueue();
            MockEndpointCatalog endCatalog      = new MockEndpointCatalog();

            endCatalog.Endpoints.Add("E1", new MockEndpoint("E1"));
            endCatalog.Endpoints.Add("E2", new MockEndpoint("E2"));
            endCatalog.Endpoints.Add("E3", new MockEndpoint("E3"));
            endCatalog.Endpoints["E1"].Default = new MockEndpointConfig("DefaultURI1");
            endCatalog.Endpoints["E2"].Default = new MockEndpointConfig("DefaultURI2");

            MockConnectionMonitor cm = CreateConnectionManager();

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
            MockRequestDispatcher disp = MockRequestDispatcher.Instance;

            //All these request have enough stamps to be dispatched
            Request r1 = new Request();

            r1.Endpoint        = "E1";
            r1.Behavior.Stamps = 9;

            Request r2 = new Request();

            r2.Endpoint        = "E2";
            r2.Behavior.Stamps = 9;

            //no endpoint
            Request r3 = new Request();

            r3.Endpoint        = "E3";
            r3.Behavior.Stamps = 9;

            queue.Enqueue(r1);
            queue.Enqueue(r2);
            queue.Enqueue(r3);

            disp.SessionAllowDispatchs = 2;             //Just allow the first two request dispatch
            cm.MockChangeConnectionStatus(false);       //Is not connected
            mgr.StartAutomaticDispatch();
            mgr.Join(1000);
            Assert.AreEqual(0, disp.RequestsReceived.Count); //should hold on until connection
            cm.MockChangeConnectionStatus(true);             //Should launch 1 request and stay locked in the second dispatch
            mgr.Join(1000);
            Assert.AreEqual(1, disp.RequestsReceived.Count);
            cm.MockChangeConnectionStatus(false);
            disp.SessionAllowDispatchs = null;             //Unlock the locked dispatch.
            mgr.Join(1000);

            //Only the two first request should been dispatched
            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.IsTrue(disp.RequestsReceived.Contains(r2));
            Assert.IsFalse(disp.RequestsReceived.Contains(r3));

            Assert.AreEqual(2, disp.RequestsReceived.Count);
            Assert.AreEqual(1, queue.GetCount());
        }
        public void DispatchRequestsForConnectionStatusChangeAccordingToStamps()
        {
            MockRequestQueue    queue           = new MockRequestQueue();
            MockRequestQueue    deadletterQueue = new MockRequestQueue();
            MockEndpointCatalog endCatalog      = new MockEndpointCatalog();

            endCatalog.Endpoints.Add("E1", new MockEndpoint("E1"));
            endCatalog.Endpoints.Add("E2", new MockEndpoint("E2"));
            endCatalog.Endpoints.Add("E3", new MockEndpoint("E3"));
            endCatalog.Endpoints["E1"].Default = new MockEndpointConfig("DefaultURI1");
            endCatalog.Endpoints["E2"].Default = new MockEndpointConfig("DefaultURI2");

            MockConnectionMonitor cm = CreateConnectionManager();

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
            MockRequestDispatcher disp = MockRequestDispatcher.Instance;

            //ok
            Request r1 = new Request();

            r1.Endpoint        = "E1";
            r1.Behavior.Stamps = 9;

            //not enough stamps
            Request r2 = new Request();

            r2.Endpoint        = "E2";
            r2.Behavior.Stamps = 1;

            //no endpoint
            Request r3 = new Request();

            r3.Endpoint        = "E3";
            r3.Behavior.Stamps = 9;

            queue.Enqueue(r1);
            queue.Enqueue(r2);
            queue.Enqueue(r3);

            mgr.StartAutomaticDispatch();

            Assert.AreEqual(0, disp.RequestsReceived.Count);

            cm.MockChangeConnectionStatus(true);

            mgr.Join(1000);

            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.IsFalse(disp.RequestsReceived.Contains(r3));
            Assert.IsFalse(disp.RequestsReceived.Contains(r2));

            Assert.AreEqual(1, disp.RequestsReceived.Count);
            Assert.AreEqual(2, queue.GetCount());
        }
        public void DispatchAllRequestByTagBypassingCost()
        {
            MockRequestQueue    queue           = new MockRequestQueue();
            MockRequestQueue    deadletterQueue = new MockRequestQueue();
            MockEndpointCatalog endCatalog      = CreateEndpointCatalog();

            MockConnectionMonitor connectionMonitor = CreateConnectionManager();

            connectionMonitor.MockChangeConnectionStatus(true);

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, connectionMonitor, endCatalog);
            MockRequestDispatcher disp     = MockRequestDispatcher.Instance;
            OfflineBehavior       behavior = new OfflineBehavior();

            behavior.Tag = "A";

            Request r1 = new Request();

            r1.Endpoint = "Endpoint";
            Request r2 = new Request();

            r2.Endpoint = "Endpoint";
            Request r3 = new Request();

            r3.Endpoint = "Endpoint";

            r1.Behavior = behavior;
            r3.Behavior = behavior;

            queue.Enqueue(r1);
            queue.Enqueue(r2);
            queue.Enqueue(r3);

            mgr.DispatchPendingRequestsByTag("A");
            mgr.Join(1000);

            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.IsTrue(disp.RequestsReceived.Contains(r3));
            Assert.IsFalse(disp.RequestsReceived.Contains(r2));

            Assert.AreEqual(2, disp.RequestsReceived.Count);
            Assert.AreEqual(1, queue.GetCount());
        }
        public void DispatchAllPendingRequestsDoesntDispatchRequestsForUnavailableEndpoints()
        {
            MockRequestQueue      queue             = new MockRequestQueue();
            MockRequestQueue      deadletterQueue   = new MockRequestQueue();
            MockEndpointCatalog   endCatalog        = CreateEndpointCatalog();
            MockConnectionMonitor connectionMonitor = CreateConnectionManager();

            connectionMonitor.MockChangeConnectionStatus(true);

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, connectionMonitor, endCatalog);
            MockRequestDispatcher disp = MockRequestDispatcher.Instance;

            Request r1 = new Request();

            r1.Endpoint = "Endpoint";
            Request r2 = new Request();

            r2.Endpoint = "Unavailable";
            Request r3 = new Request();

            r3.Endpoint = "Endpoint";

            queue.Enqueue(r1);
            queue.Enqueue(r2);
            queue.Enqueue(r3);

            mgr.DispatchAllPendingRequests();
            mgr.Join(1000);

            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.IsTrue(disp.RequestsReceived.Contains(r3));
            Assert.IsFalse(disp.RequestsReceived.Contains(r2));

            Assert.AreEqual(2, disp.RequestsReceived.Count);
            Assert.AreEqual(1, queue.GetCount());
        }
        public void RequestEndpointAsEmptyStringIsDispatchedWhenEndpointCatalogIsConfigured()
        {
            MockRequestQueue    queue      = new MockRequestQueue();
            MockEndpointCatalog endCatalog = CreateEndpointCatalog();
            MockEndpoint        ep         = new MockEndpoint("A");

            ep.Default = new MockEndpointConfig("address");

            endCatalog.Endpoints.Add("A", ep);

            MockRequestQueue deadletterQueue = new MockRequestQueue();

            MockConnectionMonitor cm = new MockConnectionMonitor();

            cm.CurrentNetwork         = "net";
            cm.CurrentConnectionPrice = 5;
            cm.MockChangeConnectionStatus(true);

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
            MockRequestDispatcher disp = MockRequestDispatcher.Instance;

            Request r1 = new Request();

            r1.Endpoint        = "";
            r1.Behavior.Stamps = 9;

            disp.ForceFails = false;
            queue.Enqueue(r1);
            mgr.StartAutomaticDispatch();
            mgr.Join(1000);

            Assert.AreEqual(1, disp.RequestsReceived.Count);
            Assert.IsTrue(disp.RequestsReceived.Contains(r1));
            Assert.AreEqual(0, queue.GetCount());
        }
        public void ExpiredMessagesFiresRequestDispatchedAsExpired()
        {
            MockRequestDispatcher disp              = new MockRequestDispatcher();
            MockEndpointCatalog   endCatalog        = CreateEndpointCatalog();
            MockConnectionMonitor connectionMonitor = CreateConnectionManager();
            MockRequestQueue      requestQueue      = new MockRequestQueue();
            MockRequestQueue      deadLetterQueue   = new MockRequestQueue();
            DispatchResult?       result            = null;

            connectionMonitor.CurrentConnectionPrice = 1;

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(requestQueue, deadLetterQueue, connectionMonitor, endCatalog);
            mgr.RequestDispatched += delegate(object sender, RequestDispatchedEventArgs args) { result = args.Result; };

            Request request = new Request();

            request.Endpoint            = "Endpoint";
            request.Behavior.MessageId  = Guid.NewGuid();
            request.Behavior.Stamps     = 9;
            request.OnlineProxyType     = typeof(MockService);
            request.MethodName          = "DoWithNoParams";
            request.Behavior.Expiration = DateTime.Now - TimeSpan.FromDays(1);
            mgr.RequestQueue.Enqueue(request);

            connectionMonitor.MockChangeConnectionStatus(true);

            mgr.DispatchRequest(request);
            //mgr.StartAutomaticDispatch();
            mgr.Join(1000);

            Assert.AreEqual(DispatchResult.Expired, result);
            Assert.AreEqual(0, disp.RequestsReceived.Count);
            Assert.AreEqual(0, deadLetterQueue.GetCount());
        }
        public void ExpiredMessagesDontGetDispatched()
        {
            MockRequestQueue      queue      = new MockRequestQueue();
            MockRequestQueue      dlq        = new MockRequestQueue();
            MockRequestDispatcher disp       = new MockRequestDispatcher();
            MockEndpointCatalog   endCatalog = new MockEndpointCatalog();

            endCatalog.Endpoints.Add("E1", new MockEndpoint("E1"));
            endCatalog.Endpoints["E1"].Default = new MockEndpointConfig("DefaultURI2");

            MockConnectionMonitor cm = new MockConnectionMonitor();

            cm.CurrentNetwork         = "net";
            cm.CurrentConnectionPrice = 5;
            cm.MockChangeConnectionStatus(true);

            RequestManager mgr = RequestManager.Instance;

            mgr.Initialize <MockRequestDispatcher>(queue, dlq, cm, endCatalog);

            Request r1 = new Request();

            r1.Endpoint            = "E1";
            r1.Behavior.Stamps     = 9;
            r1.Behavior.Expiration = DateTime.Now - TimeSpan.FromHours(1);             //Already expired

            mgr.StartAutomaticDispatch();
            queue.Enqueue(r1);
            mgr.Join(1000);

            Assert.AreEqual(0, disp.RequestsReceived.Count);
            Assert.IsFalse(disp.RequestsReceived.Contains(r1));
            Assert.AreEqual(0, queue.GetCount());
            Assert.AreEqual(0, dlq.GetCount());
            Assert.IsFalse(dlq.requests.Contains(r1));
        }