public void CreatingRequestWithReturnValueAndParams()
{
MockRequestQueue queue = new MockRequestQueue();
OfflineMockService proxy = new OfflineMockService(queue);
MockServiceDataContract obj = new MockServiceDataContract("Jose", 31);
proxy.DoWithParamsAndReturn(1, obj);
Request r = queue.GetNextRequest();
Assert.AreSame(obj, r.CallParameters[1]);
Assert.AreEqual("MockService", r.Endpoint);
Assert.AreEqual("DoWithParamsAndReturn", r.MethodName);
Assert.AreEqual(typeof(MockService), r.OnlineProxyType);
Assert.AreEqual("OnDoWithParamsAndReturnReturn", r.Behavior.ReturnCallback.TargetMethodName);
Assert.AreEqual(typeof(OfflineMockServiceCallbacks), r.Behavior.ReturnCallback.TargetType);
Assert.AreEqual("OnMockServiceException", r.Behavior.ExceptionCallback.TargetMethodName);
Assert.AreEqual(typeof(OfflineMockServiceCallbacks), r.Behavior.ExceptionCallback.TargetType);
//these test the default behavior; which should have been set by the recipe when creating the OfflineSvcAgent
Assert.AreEqual(null, r.Behavior.Expiration);
Assert.AreEqual(1, r.Behavior.MaxRetries);
Assert.AreEqual(3, r.Behavior.Stamps);
Assert.AreEqual("", r.Behavior.Tag);
Assert.IsNotNull(r.Behavior.MessageId);
}
public void DispatchOneRequestForciblyOnlyWorksIfItsConnected()
{
MockRequestQueue deadletterQueue = new MockRequestQueue();
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
MockRequestQueue requestQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r = new Request();
r.Endpoint = "Endpoint";
mgr.RequestQueue.Enqueue(r);
connectionMonitor.MockChangeConnectionStatus(false);
mgr.DispatchRequest(r); //
mgr.DispatchRequest(r); // r should be dispatched once
mgr.DispatchRequest(r); //
mgr.Join(1000);
Assert.AreEqual(0, disp.RequestsReceived.Count);
connectionMonitor.MockChangeConnectionStatus(true);
mgr.DispatchRequest(r);
mgr.Join(1000);
Assert.AreEqual(1, disp.RequestsReceived.Count); // r should be dispatched once
Assert.AreSame(r, disp.RequestsReceived[0]);
}
public void RequestManagerPassesConnectionPriceToQueue()
{
MockRequestQueue queue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
connectionMonitor.MockChangeConnectionStatus(true);
MockEndpoint ep = new MockEndpoint("A");
ep.Default = new MockEndpointConfig("address");
endCatalog.Endpoints.Add("A", ep);
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, connectionMonitor, endCatalog);
Request request = new Request();
request.Endpoint = "A";
request.Behavior.Stamps = 9;
queue.Enqueue(request);
connectionMonitor.CurrentConnectionPrice = 5;
mgr.DispatchAllPendingRequestsForConnection();
mgr.Join(1000);
Assert.AreEqual(5, queue.CriteriaReceivedPrice);
Assert.AreEqual(0, queue.requests.Count);
}
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 CreateOnlineProxyAndInvokeResultsInRequestInQueue()
{
MockRequestQueue queue = new MockRequestQueue();
OfflineMockService proxy = new OfflineMockService(queue);
proxy.DoWithNoParams();
Request r = queue.GetNextRequest();
Assert.AreEqual("DoWithNoParams", r.MethodName);
Assert.AreEqual("MockService", r.Endpoint);
Assert.AreSame(typeof(MockService), r.OnlineProxyType);
OfflineBehavior defaultBehavior = new OfflineBehavior();
defaultBehavior.Expiration = null;
defaultBehavior.MaxRetries = 1;
defaultBehavior.ReturnCallback = new CommandCallback(typeof(OfflineMockServiceCallbacks), "DoWithNoParamsCallback");
defaultBehavior.ExceptionCallback = new CommandCallback(typeof(OfflineMockServiceCallbacks), "OfflineCallFailed");
defaultBehavior.Stamps = 3;
defaultBehavior.Tag = "";
Assert.AreEqual(defaultBehavior.Expiration, r.Behavior.Expiration);
Assert.AreEqual(defaultBehavior.MaxRetries, r.Behavior.MaxRetries);
Assert.AreEqual(defaultBehavior.ReturnCallback.TargetMethodName, r.Behavior.ReturnCallback.TargetMethodName);
Assert.AreEqual(defaultBehavior.ReturnCallback.TargetType, r.Behavior.ReturnCallback.TargetType);
Assert.AreEqual(defaultBehavior.Stamps, r.Behavior.Stamps);
Assert.AreEqual(defaultBehavior.Tag, r.Behavior.Tag);
}
public void CanSpecifyBehaviorsForTheRequest()
{
MockRequestQueue queue = new MockRequestQueue();
OfflineMockService proxy = new OfflineMockService(queue);
OfflineBehavior beh = new OfflineBehavior();
beh.Tag = "tag";
beh.Stamps = 3;
beh.MaxRetries = 5;
beh.ReturnCallback = new CommandCallback(typeof(OfflineMockServiceCallbacks), "SomeOtherMethod");
beh.Expiration = DateTime.MinValue;
proxy.DoWithNoParams(beh);
Request r = queue.GetNextRequest();
Assert.AreEqual(beh, r.Behavior);
Assert.AreEqual(DateTime.MinValue, r.Behavior.Expiration);
Assert.AreEqual(5, r.Behavior.MaxRetries);
Assert.AreEqual("SomeOtherMethod", r.Behavior.ReturnCallback.TargetMethodName);
Assert.AreEqual(typeof(OfflineMockServiceCallbacks), r.Behavior.ReturnCallback.TargetType);
Assert.AreEqual(3, r.Behavior.Stamps);
Assert.AreEqual("tag", r.Behavior.Tag);
}
public void EnqueDoesntDispatchIfManagerIsStopped()
{
MockRequestQueue queue = new MockRequestQueue();
MockRequestQueue deadletterQueue = 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;
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
Request r1 = new Request();
r1.Endpoint = "E1";
r1.Behavior.Stamps = 9;
mgr.StartAutomaticDispatch();
mgr.StopAutomaticDispatch();
queue.Enqueue(r1);
mgr.Join(1000);
Assert.AreEqual(0, disp.RequestsReceived.Count);
}
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 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 DispatchRequestsByTagUsesDifferentThread()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r = new Request();
r.Behavior.Tag = "Tag";
r.Endpoint = "E1";
mgr.RequestQueue.Enqueue(r);
disp.ThreadId = 0;
requestQueue.ThreadId = 0;
connectionMonitor.MockChangeConnectionStatus(true);
mgr.DispatchPendingRequestsByTag("Tag");
mgr.Join(1000);
int threadId = Thread.CurrentThread.ManagedThreadId;
Assert.AreNotEqual(threadId, requestQueue.ThreadId, "Call to queue should have been on a different thread");
Assert.AreNotEqual(threadId, disp.ThreadId, "Call to dispatcher shoul dhave been on a different thread");
Assert.AreEqual(disp.ThreadId, requestQueue.ThreadId);
Assert.AreNotEqual(0, disp.ThreadId);
Assert.AreSame(r, disp.RequestsReceived[0]);
Assert.AreEqual(1, disp.RequestsReceived.Count);
}
public void ManangerSendsSentEventAfterRequestSent()
{
MockEndpointCatalog catalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = new MockConnectionMonitor();
IRequestQueue queue = new MockRequestQueue();
connectionMonitor.MockChangeConnectionStatus(true);
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, connectionMonitor, catalog);
dispatchedRequest = null;
mgr.RequestDispatched += new EventHandler <RequestDispatchedEventArgs>(OnRequestDispatched);
Request request = new Request();
request.Endpoint = "Endpoint";
request.Behavior.MessageId = Guid.NewGuid();
request.Behavior.Stamps = 9;
request.OnlineProxyType = typeof(MockService);
request.MethodName = "DoWithNoParams";
mgr.RequestQueue.Enqueue(request);
mgr.DispatchAllPendingRequests();
mgr.Join(1000);
Assert.IsNotNull(dispatchedRequest);
Assert.AreEqual(DispatchResult.Succeeded, dispatchResult);
}
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 DispatchOneRequestForciblyRemoveItFromTheQueue()
{
MockRequestQueue deadletterQueue = new MockRequestQueue();
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
MockRequestQueue requestQueue = new MockRequestQueue();
connectionMonitor.MockChangeConnectionStatus(true);
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r = new Request();
r.Endpoint = "Endpoint";
mgr.RequestQueue.Enqueue(r);
Assert.AreEqual(1, mgr.RequestQueue.GetCount());
mgr.DispatchRequest(r);
mgr.Join(1000);
Assert.AreEqual(0, mgr.RequestQueue.GetCount());
Assert.AreSame(r, disp.RequestsReceived[0]);
Assert.IsFalse(requestQueue.requests.Contains(r));
}
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 DispatchRequestOnConnectionChangesRestartsActiveCommand()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r1 = CreateRequest(9, String.Empty, "E1");
mgr.RequestQueue.Enqueue(r1);
Request r2 = CreateRequest(3, String.Empty, "E1");
mgr.RequestQueue.Enqueue(r2);
Request r3 = CreateRequest(9, String.Empty, "E1");
mgr.RequestQueue.Enqueue(r3);
MockRequestDispatcher.Block = true;
connectionMonitor.MockChangeConnectionStatus(false);
mgr.StartAutomaticDispatch();
connectionMonitor.CurrentNetwork = "net";
connectionMonitor.CurrentConnectionPrice = 9;
connectionMonitor.MockChangeConnectionStatus(true); //Should starts OnAutomaticDispatch of { r1, r3 }
Thread.Sleep(30); //Starts r1 dispatching which is blocked
//Change to a price 3 connection
connectionMonitor.MockChangeConnectionStatus(false); //Disconnect
MockRequestDispatcher.Block = false; //Unblock and finish the r1 dispatching
connectionMonitor.CurrentConnectionPrice = 3;
Thread.Sleep(30);
connectionMonitor.MockChangeConnectionStatus(true); //Should restart active command {r2, r3}
//Should starts OnAutomaticDispatch
Thread.Sleep(30);
MockRequestDispatcher.Block = false;
mgr.StopAutomaticDispatch();
mgr.Join(1000);
Assert.AreEqual(3, disp.RequestsReceived.Count);
Assert.AreSame(r1, disp.RequestsReceived[0]);
Assert.AreEqual(r2, disp.RequestsReceived[1]);
Assert.AreEqual(r3, disp.RequestsReceived[2]);
}
public void DispatchRequestForCurrentConnectionShouldCheckForActiveConnection()
{
MockEndpointCatalog catalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
IRequestQueue queue = new MockRequestQueue();
IRequestQueue dlq = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, dlq, connectionMonitor, catalog);
MockRequestDispatcher dispatcher = MockRequestDispatcher.Instance;
Request request1 = new Request();
request1.Endpoint = "Endpoint";
request1.Behavior.MessageId = Guid.NewGuid();
request1.Behavior.Stamps = 9;
request1.OnlineProxyType = typeof(MockService);
request1.MethodName = "DoWithNoParams";
queue.Enqueue(request1);
Request request2 = new Request();
request2.Endpoint = "Endpoint";
request2.Behavior.MessageId = Guid.NewGuid();
request2.Behavior.Stamps = 9;
request2.OnlineProxyType = typeof(MockService);
request2.MethodName = "DoWithNoParams";
queue.Enqueue(request2);
connectionMonitor.MockChangeConnectionStatus(true);
MockRequestDispatcher.Block = true;
mgr.StartAutomaticDispatch();
Thread.Sleep(30);
connectionMonitor.MockChangeConnectionStatus(false);
MockRequestDispatcher.Block = false;
Thread.Sleep(30);
mgr.DispatchAllPendingRequests();
Thread.Sleep(30);
mgr.Join(1000);
Assert.AreEqual(1, dispatcher.RequestsReceived.Count); //request succeeded
}
public void RequestManagerIsCreatedStopped()
{
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 = CreateConnectionManager();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, deadletterQueue, cm, endCatalog);
Assert.IsFalse(mgr.AutomaticDispatcherRunning);
}
public void DispatchWithAutomaticDispatchStopsDispatchingWhenConnectionGoesAway()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r1 = new Request();
r1.Behavior.Stamps = 9;
r1.Endpoint = "E1";
mgr.RequestQueue.Enqueue(r1);
Request r2 = new Request();
r2.Behavior.Stamps = 3;
r2.Endpoint = "E1";
mgr.RequestQueue.Enqueue(r2);
Request r3 = new Request();
r3.Behavior.Stamps = 9;
r3.Endpoint = "E1";
mgr.RequestQueue.Enqueue(r3);
MockRequestDispatcher.Block = true;
connectionMonitor.CurrentNetwork = "net";
connectionMonitor.CurrentConnectionPrice = 3;
connectionMonitor.MockChangeConnectionStatus(true);
mgr.StartAutomaticDispatch();
Thread.Sleep(30);
connectionMonitor.MockChangeConnectionStatus(false);
Thread.Sleep(30);
MockRequestDispatcher.Block = false;
mgr.Join(1000);
mgr.StartAutomaticDispatch();
Assert.AreEqual(1, disp.RequestsReceived.Count);
Assert.AreSame(r1, disp.RequestsReceived[0]);
}
public void Request_Is_Retried()
{
// arrange
var userWriter = new Mock<IUserWriter>();
var requestQueue = new MockRequestQueue();
var responseQueue = new MockResponseQueue();
var controller = new CrawlerController(userWriter.Object, requestQueue, responseQueue, new RecentFriendRegistry());
var retryRequest = new GetFriendsRequest("test");
var errorResponse = new ErrorResponse(retryRequest, "fail whale");
// act
controller.ProcessResponse(errorResponse);
// assert
Assert.That(requestQueue.QueuedMessages, Has.Count(1));
Assert.That(requestQueue.QueuedMessages.Single(), Is.SameAs(retryRequest));
}
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 DispatchingRequestWhenConnectionDownRetriesRequestWhenConnectionReturns()
{
MockEndpointCatalog catalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
IRequestQueue queue = new MockRequestQueue();
IRequestQueue dlq = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(queue, dlq, connectionMonitor, catalog);
MockRequestDispatcher dispatcher = MockRequestDispatcher.Instance;
Request request = new Request();
request.Endpoint = "Endpoint";
request.Behavior.MessageId = Guid.NewGuid();
request.Behavior.Stamps = 9;
request.OnlineProxyType = typeof(MockService);
request.MethodName = "DoWithNoParams";
queue.Enqueue(request);
dispatcher.ForceFails = true;
connectionMonitor.MockChangeConnectionStatus(true);
MockRequestDispatcher.Block = true;
mgr.StartAutomaticDispatch();
Thread.Sleep(30);
connectionMonitor.MockChangeConnectionStatus(false);
MockRequestDispatcher.Block = false;
Thread.Sleep(30);
Assert.AreEqual(0, dispatcher.RequestsReceived.Count); //request tried and failed
Assert.AreEqual(0, mgr.DeadLetterQueue.GetCount()); //request not put in DLQ
dispatcher.ForceFails = false;
connectionMonitor.MockChangeConnectionStatus(true);
Thread.Sleep(30);
mgr.Join(1000);
Assert.AreEqual(1, dispatcher.RequestsReceived.Count); //request succeeded
Assert.AreSame(request, dispatcher.RequestsReceived[0]);
}
public void CreatingRequestWithReturnValueAndSpecificBehavior()
{
MockRequestQueue queue = new MockRequestQueue();
OfflineMockService proxy = new OfflineMockService(queue);
MockServiceDataContract obj = new MockServiceDataContract("Jose", 31);
OfflineBehavior behavior = new OfflineBehavior();
behavior.MaxRetries = 7;
behavior.Stamps = 5;
behavior.Tag = "Test";
behavior.ReturnCallback =
new CommandCallback(typeof(OfflineMockServiceCallbacks), "OnDoWithParamsAndReturnAlternativeReturn");
behavior.ExceptionCallback = new CommandCallback(typeof(OfflineMockServiceCallbacks), "OnMockServiceOtherException");
DateTime expDate = DateTime.Now + TimeSpan.FromHours(2);
behavior.Expiration = expDate;
Guid behId = Guid.NewGuid();
behavior.MessageId = behId;
proxy.DoWithParamsAndReturn(1, obj, behavior);
Request r = queue.GetNextRequest();
Assert.AreEqual(behId, r.Behavior.MessageId);
Assert.AreSame(obj, r.CallParameters[1]);
Assert.AreEqual("MockService", r.Endpoint);
Assert.AreEqual("DoWithParamsAndReturn", r.MethodName);
Assert.AreEqual(typeof(MockService), r.OnlineProxyType);
Assert.AreEqual("OnDoWithParamsAndReturnAlternativeReturn", r.Behavior.ReturnCallback.TargetMethodName);
Assert.AreEqual(typeof(OfflineMockServiceCallbacks), r.Behavior.ReturnCallback.TargetType);
Assert.AreEqual("OnMockServiceOtherException", r.Behavior.ExceptionCallback.TargetMethodName);
Assert.AreEqual(typeof(OfflineMockServiceCallbacks), r.Behavior.ExceptionCallback.TargetType);
//these test the default behavior; which should have been set by the recipe when creating the OfflineSvcAgent
Assert.AreEqual(expDate, r.Behavior.Expiration);
Assert.AreEqual(7, r.Behavior.MaxRetries);
Assert.AreEqual(5, r.Behavior.Stamps);
Assert.AreEqual("Test", r.Behavior.Tag);
}
public void ErrorResponse_Is_Queued()
{
// arrange
var requestQueue = new MockRequestQueue();
var responseQueue = new MockResponseQueue();
var statusService = new Mock<IStatusService>();
statusService.Setup(ss => ss.GetFriendsOf("test")).Throws(new XmlException("Twitter is full of FAIL!"));
var crawler = new TwitterCrawler(requestQueue, responseQueue, statusService.Object);
// act
var friendRequest = new GetFriendsRequest("test");
crawler.ProcessRequest(friendRequest);
// assert
Assert.That(responseQueue.QueuedMessages, Has.Count(1));
Assert.That(responseQueue.QueuedMessages.Single(), Is.TypeOf(typeof(ErrorResponse)));
var response = (ErrorResponse)responseQueue.QueuedMessages.Single();
Assert.That(response.Request, Is.SameAs(friendRequest));
}
public void DispatchingMethodsUseOnlyOneDispatchAtTheSameTime()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue Dlq = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, Dlq, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag1", 9);
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag2", 9);
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag1", 3);
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag1", 3);
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag2", 9);
EnqueueNewRequest(mgr.RequestQueue, "E1", "Tag1", 9);
MockRequestDispatcher.Block = false;
MockRequestDispatcher.SlowMode = true;
MockRequestDispatcher.UniqueDispatch = true;
MockRequestDispatcher.DispatchRunning = 0;
connectionMonitor.CurrentConnectionPrice = 3;
mgr.StartAutomaticDispatch();
mgr.DispatchPendingRequestsByTag("Tag1");
connectionMonitor.MockChangeConnectionStatus(true);
mgr.DispatchRequest(mgr.RequestQueue.GetNextRequest());
connectionMonitor.CurrentConnectionPrice = 8;
mgr.DispatchAllPendingRequestsForConnection();
connectionMonitor.MockChangeConnectionStatus(false);
mgr.DispatchAllPendingRequests();
connectionMonitor.MockChangeConnectionStatus(true);
mgr.Join(10000);
mgr.StopAutomaticDispatch();
MockRequestDispatcher.SlowMode = false;
Assert.IsTrue(MockRequestDispatcher.UniqueDispatch);
Assert.AreEqual(0, MockRequestDispatcher.DispatchRunning);
Assert.AreEqual(6, disp.RequestsReceived.Count);
}
public void DispatchDoesNotDispatchRequestsOutOfTheQueue()
{
MockRequestDispatcher disp = new MockRequestDispatcher();
MockRequestQueue deadletterQueue = new MockRequestQueue();
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionManager();
MockRequestQueue requestQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
Request r = new Request();
r.Endpoint = "Endpoint";
connectionMonitor.MockChangeConnectionStatus(true);
mgr.DispatchRequest(r);
mgr.Join(1000);
Assert.AreEqual(0, disp.RequestsReceived.Count);
}
public void DispatchRequestInSameOrderAsCommandsWereEntered()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r1 = CreateRequest(9, "Tag", "E1");
mgr.RequestQueue.Enqueue(r1);
Request r2 = CreateRequest(3, String.Empty, "E1");
mgr.RequestQueue.Enqueue(r2);
Request r3 = CreateRequest(9, "Tag", "E1");
mgr.RequestQueue.Enqueue(r3);
connectionMonitor.MockChangeConnectionStatus(false);
mgr.StartAutomaticDispatch();
mgr.DispatchPendingRequestsByTag("Tag"); //Should dispatch r1 and r3
Thread.Sleep(30);
connectionMonitor.CurrentNetwork = "net";
connectionMonitor.CurrentConnectionPrice = 3;
connectionMonitor.MockChangeConnectionStatus(true); //Should starts OnAutomaticDispatch to dispatch r2
Thread.Sleep(30);
mgr.Join(1000);
Assert.AreEqual(3, disp.RequestsReceived.Count);
Assert.AreEqual(r1, disp.RequestsReceived[0]);
Assert.AreEqual(r3, disp.RequestsReceived[1]);
Assert.AreEqual(r2, disp.RequestsReceived[2]);
}
public void DispatchRequestDoesNotDispatchPreviouslyDispatchedRequests()
{
MockEndpointCatalog endCatalog = CreateEndpointCatalog();
MockConnectionMonitor connectionMonitor = CreateConnectionMonitor();
MockRequestQueue requestQueue = new MockRequestQueue();
MockRequestQueue deadletterQueue = new MockRequestQueue();
RequestManager mgr = RequestManager.Instance;
mgr.Initialize <MockRequestDispatcher>(requestQueue, deadletterQueue, connectionMonitor, endCatalog);
MockRequestDispatcher disp = MockRequestDispatcher.Instance;
Request r1 = CreateRequest(9, "Tag", "E1");
mgr.RequestQueue.Enqueue(r1);
Request r2 = CreateRequest(9, "Dispatched", "E1");
mgr.RequestQueue.Enqueue(r2);
Request r3 = CreateRequest(9, "Tag", "E1");
mgr.RequestQueue.Enqueue(r3);
connectionMonitor.MockChangeConnectionStatus(false);
mgr.DispatchAllPendingRequests(); //When connection comes up it will try to dispatch r1, r2 and r3
Thread.Sleep(30);
connectionMonitor.CurrentNetwork = "net";
connectionMonitor.MockChangeConnectionStatus(true);
mgr.DispatchRequest(r2); //Explicitly dispatch for r2 ('cause there is an active connection should start
//the dispatching thread and process all pending dispatch commands).
Thread.Sleep(30);
mgr.Join(1000);
Assert.AreEqual(3, disp.RequestsReceived.Count);
Assert.AreEqual(r1, disp.RequestsReceived[0]);
Assert.AreEqual(r2, disp.RequestsReceived[1]);
Assert.AreEqual(r3, disp.RequestsReceived[2]);
}
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));
}
public OfflineMockService(MockRequestQueue requestQueue)
{
this.requestQueue = requestQueue;
}
