public void MessageFromSubscriberIsSentToCorrectHost() { byte[] b = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); FakeSender sender = new FakeSender(); SenderBase.FactoryMethod = e => sender; Message msg = new Message(); msg.Data = b; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); server.DiscoveryMessageEvent(msg, ep); TestSubscriber s = new TestSubscriber(); s.Subscribe(); server.SubscribeResponseMessageEvent(sender._id); Thread.Sleep(1000); s.SendMessage(); Thread.Sleep(1000); Assert.AreEqual(1, sender._messages[MessageType.ApplicationMessage]); }
public async Task SendRequest <T>(string serviceUri, HttpRequestBase request, Action <T> callback) where T : HttpResponseBase, new() { if (typeof(T) == typeof(CreateRoomResponse)) { var roomId = _createRoomDelegate(_roomProperties, _gameApplication, ((CreateRoomRequest)request).RoomId); callback(new CreateRoomResponse(roomId) as T); } else if (typeof(T) == typeof(GetServerInfoListResponse)) { callback(FakeSender.CreateGetServerInfoListResponse <T>() as T); } else if (typeof(T) == typeof(ValidateSessionIdResponse)) { callback(new ValidateSessionIdResponse() { ResultCode = ResultCode.OK } as T); } else { callback(new T()); } }
public void NetworkControllerSubscriptionMessageIsProcessed() { byte[] b = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); FakeSender sender = new FakeSender(); SenderBase.FactoryMethod = e => sender; Message msg = new Message(); msg.Data = b; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); server.DiscoveryMessageEvent(msg, ep); PublisherWithCallbackMethod p = new PublisherWithCallbackMethod(); Start.Publisher(p); server.SubscriptionMessage(typeof(bool)); Thread.Sleep(1000); Assert.IsTrue(sender._messages.ContainsKey(MessageType.SubscribeResponse)); }
public void NetworkControllerSendShutDownMessage() { byte[] b = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); SenderBase.FactoryMethod = e => sender; Message msg = new Message(); msg.Data = b; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); server.DiscoveryMessageEvent(msg, ep); Stop.Ella(); Assert.AreEqual(1, sender._messages[MessageType.NodeShutdown]); }
public void NetworkControllerSubscriptionCacheIsSentOnlyOnce() { byte[] b = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); SenderBase.FactoryMethod = e => sender; TestSubscriber subscriber = new TestSubscriber(); subscriber.Subscribe(); Message msg = new Message(); msg.Data = b; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); server.DiscoveryMessageEvent(msg, ep); Thread.Sleep(3000); Assert.AreEqual(1, sender._messages[MessageType.Subscribe]); }
public void MessageQueuedForReceive_IsNotLogged_IfReceiveAborts() { ManualResetEvent wait = new ManualResetEvent(false); var sender = new FakeSender { Destination = new Endpoint("localhost", 23457), Messages = new[] { new Message { Id = new MessageId { MessageIdentifier = Guid.NewGuid(), SourceInstanceId = Guid.NewGuid() }, SentAt = DateTime.Now, Queue = "h", Data = new byte[] { 1, 2, 4, 5 } } } }; sender.SendCompleted += () => wait.Set(); var logger = new RecordingLogger(); sender.Send(); wait.WaitOne(TimeSpan.FromSeconds(1)); Wait.Until(() => logger.MessagesQueuedForReceive.Any(), timeoutInMilliseconds: 1000) .ShouldBeFalse(); }
public void MessageQueuedForReceive_EventNotRaised_IfReceiveAborts() { ManualResetEvent wait = new ManualResetEvent(false); using (var sender = new FakeSender { Destination = new Endpoint("localhost", 23457), FailToAcknowledgeReceipt = true, Messages = new[] { new Message { Id = new MessageId { MessageIdentifier = Guid.NewGuid(), SourceInstanceId = Guid.NewGuid() }, SentAt = DateTime.Now, Queue = "h", Data = new byte[] { 1, 2, 4, 5 } } } }) { sender.SendCompleted += () => wait.Set(); using (var receiver = SetupReciever()) { receiver.MessageQueuedForReceive += RecordMessageEvent; sender.Send(); wait.WaitOne(); Thread.Sleep(1000); receiver.MessageQueuedForReceive -= RecordMessageEvent; } } Assert.Null(messageEventArgs); }
public void SetUp() { fakeSender = new FakeSender(); var settingsHolder = new SettingsHolder(); faultManager = new FaultManager(fakeSender, new Configure(settingsHolder, new FakeContainer(), new List <Action <IConfigureComponents> >(), null), new BusNotifications()); faultManager.Init(new Address("fake", "fake")); }
static string address = "25.3.124.57"; // адрес сервера static void Main(string[] args) { var a = new FakeSender(address, port); a.Send(); a.DataToSend.Add(Encoding.Unicode.GetBytes("ads")); while (true) { } }
public void NetworkControllerStart() { NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); Assert.IsTrue(server._startedNetwork); }
public void CanBuildInstructionForPresentLoad() { ISender sender = new FakeSender(); InstructionPacketBase instructionPacket = new InstructionPacketReadPresentLoad(SERVO_ID, sender); Assert.AreEqual(0xFF, instructionPacket.StartByte1); Assert.AreEqual(0xFF, instructionPacket.StartByte2); Assert.AreEqual(0x01, instructionPacket.ServoId); Assert.AreEqual(0x04, instructionPacket.LengthOfCommand); Assert.AreEqual(0x02, instructionPacket.Instruction); Assert.AreEqual(0xCE, instructionPacket.CheckSum); var corectResult = new byte[] { 0XFF, 0XFF, 0X01, 0X04, 0X02, 0X28, 0X02, 0XCE }; Assert.AreEqual(corectResult, instructionPacket.ToByte()); }
public async Task ExecuteAsync_ResponseOk_DoesNotRetry() { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromSeconds(5) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender().Returns(HttpStatusCode.OK); var response = await retryPolicy.ExecuteAsync(client.SendRequest); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(1, client.TimesCalled); }
public void CanCreateInstructionPacketForPingId1() { ISender sender = new FakeSender(); var instructionPacket = new InstructionPacketPing(SERVO_ID, sender); Assert.AreEqual(0xFF, instructionPacket.StartByte1); Assert.AreEqual(0xFF, instructionPacket.StartByte2); Assert.AreEqual(0x01, instructionPacket.ServoId); Assert.AreEqual(0x02, instructionPacket.LengthOfCommand); Assert.AreEqual(0x01, instructionPacket.Instruction); Assert.AreEqual(0xFB, instructionPacket.CheckSum); var corectResult = new byte[] {0XFF, 0XFF, 0X01, 0X02, 0X01, 0XFB}; Assert.AreEqual(corectResult, instructionPacket.ToByte()); }
public void It_removes_staging_id_header() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint" }; var message = new TransportMessage(Guid.NewGuid().ToString(), headers); ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender); Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.Retry.StagingId")); }
public async Task ExecuteAsync_ThrottledRequest_NoHeader_GetsNextWaitTime(HttpStatusCode statusCode) { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromSeconds(10), MaxCumulativeWaitTime = TimeSpan.FromSeconds(5) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender().Returns(statusCode); var response = await retryPolicy.ExecuteAsync(client.SendRequest); Assert.Equal(statusCode, response.StatusCode); Assert.Equal(1, client.TimesCalled); }
public async Task It_removes_staging_id_header() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint" }; var message = CreateMessage(Guid.NewGuid().ToString(), headers); await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender) .ConfigureAwait(false); Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.Retry.StagingId")); }
public void It_fetches_the_body_if_provided() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint", ["ServiceControl.Retry.Attempt.MessageId"] = "MessageBodyId" }; var message = new TransportMessage(Guid.NewGuid().ToString(), headers); ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender); Assert.AreEqual("MessageBodyId", Encoding.UTF8.GetString(sender.Message.Body)); }
public void It_sends_directly_to_target_if_retry_to_is_not_provided() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint", }; var message = new TransportMessage(Guid.NewGuid().ToString(), headers); ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender); Assert.AreEqual("TargetEndpoint", sender.Options.Destination.Queue); Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.TargetEndpointAddress")); }
public void It_uses_retry_to_if_provided() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint", ["ServiceControl.RetryTo"] = "Proxy" }; var message = new TransportMessage(Guid.NewGuid().ToString(), headers); ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender); Assert.AreEqual("Proxy", sender.Options.Destination.Queue); Assert.AreEqual("TargetEndpoint", sender.Message.Headers["ServiceControl.TargetEndpointAddress"]); }
public async Task It_sends_directly_to_target_if_retry_to_is_not_provided() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint" }; var message = CreateMessage(Guid.NewGuid().ToString(), headers); await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender) .ConfigureAwait(false); Assert.AreEqual("TargetEndpoint", sender.Destination); Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.TargetEndpointAddress")); }
public async Task It_fetches_the_body_if_provided() { var sender = new FakeSender(); var headers = new Dictionary <string, string> { ["ServiceControl.Retry.StagingId"] = "SomeId", ["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint", ["ServiceControl.Retry.Attempt.MessageId"] = "MessageBodyId" }; var message = CreateMessage(Guid.NewGuid().ToString(), headers); await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender) .ConfigureAwait(false); Assert.AreEqual("MessageBodyId", Encoding.UTF8.GetString(sender.Message.Body)); }
public async Task ExecuteAsync_RecoversAfterNotSuccessStatusCode() { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromMilliseconds(100) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender().Returns(HttpStatusCode.InternalServerError, HttpStatusCode.OK); var stopwatch = Stopwatch.StartNew(); var response = await retryPolicy.ExecuteAsync(client.SendRequest); stopwatch.Stop(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(2, client.TimesCalled); Assert.True(stopwatch.Elapsed > 0.8 * options.DeltaBackoff); }
public async Task ExecuteAsync_ThrottledRequest_RetryAfterHeaderWithDate_ReadsWaitTimeFromHeader(HttpStatusCode statusCode) { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromMilliseconds(100), MaxCumulativeWaitTime = TimeSpan.FromSeconds(5) }; var retryPolicy = new DefaultRetryPolicy(options); var mockResponse = new HttpResponseMessage(statusCode); mockResponse.Headers.RetryAfter = new RetryConditionHeaderValue(DateTime.UtcNow.AddSeconds(6)); var client = new FakeSender().Returns(mockResponse); var response = await retryPolicy.ExecuteAsync(client.SendRequest); Assert.Equal(statusCode, response.StatusCode); Assert.Equal(1, client.TimesCalled); }
public async Task ExecuteAsync_ThrottledRequest_RetryAfterHeaderWithNotPositiveDelta_GetsNextWaitTime(HttpStatusCode statusCode, int waitTimeInSeconds) { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromSeconds(10), MaxCumulativeWaitTime = TimeSpan.FromSeconds(5) }; var retryPolicy = new DefaultRetryPolicy(options); var mockResponse = new HttpResponseMessage(statusCode); mockResponse.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(waitTimeInSeconds)); var client = new FakeSender().Returns(mockResponse); var response = await retryPolicy.ExecuteAsync(client.SendRequest); Assert.Equal(statusCode, response.StatusCode); Assert.Equal(1, client.TimesCalled); }
public void NetworkControllerSendMessage() { byte[] data = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); SenderBase.FactoryMethod = e => sender; Message msg = new Message(); msg.Data = data; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); server.DiscoveryMessageEvent(msg, ep); TestSubscriber s = new TestSubscriber(); s.Subscribe(); byte[] b = { 1, 2 }; ApplicationMessage app = new ApplicationMessage(); app.Data = b; RemoteSubscriptionHandle rh = new RemoteSubscriptionHandle(); rh.PublisherNodeID = EllaConfiguration.Instance.NodeId + 1; Send.Message(app, rh, s); Thread.Sleep(1000); Assert.AreEqual(1, sender._messages[MessageType.ApplicationMessage]); }
public void CanCreateInstructionPacketForSyncedMovment() { ISender sender = new FakeSender(); var movment1 = new MovmentComandAX12(0, 0x010, 0x150); var movment2 = new MovmentComandAX12(1, 0x220, 0x360); var movment3 = new MovmentComandAX12(2, 0x030, 0x170); var movment4 = new MovmentComandAX12(3, 0x220, 0x380); var instructionPacket = new InstructionPacketSyncMovment(sender, movment1, movment2, movment3, movment4); var corectResult = new byte[] { 0XFF, 0XFF, 0XFE, 0X18, 0X83, 0X1E, 0X04, 0X00, 0X10, 0X00, 0X50, 0X01, 0X01, 0X20, 0X02, 0X60, 0X03, 0X02, 0X30, 0X00, 0X70, 0X01, 0X03, 0X20, 0X02, 0X80, 0X03, 0X12 }; Assert.AreEqual(corectResult, instructionPacket.ToByte()); // Console.WriteLine(BitConverter.ToString(corectResult)); // Console.WriteLine(BitConverter.ToString(instructionPacket.ToByte())); }
public void CanBuildInstructionForReadingTemperature() { ISender sender = new FakeSender(); InstructionPacketBase instructionPacket = new InstructionPacketReadTemperature(SERVO_ID, sender); Assert.AreEqual(0xFF, instructionPacket.StartByte1); Assert.AreEqual(0xFF, instructionPacket.StartByte2); Assert.AreEqual(0x01, instructionPacket.ServoId); Assert.AreEqual(0x04, instructionPacket.LengthOfCommand); Assert.AreEqual(0x02, instructionPacket.Instruction); Assert.AreEqual(0xCC, instructionPacket.CheckSum); var corectResult = new byte[] { 0XFF, 0XFF, 0X01, 0X04, 0X02, 0X2B, 0X01, 0XCC}; Assert.AreEqual(corectResult, instructionPacket.ToByte()); //temp 43 0x2B //loadL 40 0x28 //loadH 41 0x29 //Load Direction = 0 : CCW Load, Load Direction = 1: CW Load }
public void NetworkControllerUnsubscribeFrom() { byte[] b = new byte[1024]; NetworkController nc = new NetworkController(); FakeServer fs = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(fs); Networking.NetworkController = nc; Networking.Start(); SenderBase.FactoryMethod = e => sender; //this discoveryMessage is required to add the Instance to the RemoteHosts, //which is used in the NetworkController to send messages, subscribe, unsubscribe.. //must call these MessageProcessor methods by hand, because the FakeSender just fakes the Send() implementation Message msg = new Message(); msg.Data = b; msg.Sender = EllaConfiguration.Instance.NodeId + 1; msg.Type = MessageType.Discover; IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456); fs.DiscoveryMessageEvent(msg, ep); TestSubscriber s = new TestSubscriber(); s.Subscribe(); Thread.Sleep(1000); //after subscription is done: new MessageEvent of Type SubscribeResponse is faked in FakeServer fs.SubscribeResponseMessageEvent(sender._id); s.UnsubscribeFromRemote(); Thread.Sleep(1000); Assert.AreEqual(1, sender._messages[MessageType.Unsubscribe]); }
public async Task ExecuteAsync_RecoversAfterException() { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromMilliseconds(100) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender() .Throws(GetExceptionFromStatus(WebExceptionStatus.ConnectionClosed)) .Returns(HttpStatusCode.OK); var stopwatch = Stopwatch.StartNew(); var response = await retryPolicy.ExecuteAsync(client.SendRequest); stopwatch.Stop(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(2, client.TimesCalled); Assert.True(stopwatch.Elapsed > 0.8 * options.DeltaBackoff); }
public async Task ExecuteAsync_Exception_RetriesUntilCumulativeWaitTimeReached() { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromMilliseconds(100), MaxCumulativeWaitTime = TimeSpan.FromSeconds(2) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender().Throws(GetExceptionFromStatus(WebExceptionStatus.ConnectionClosed)); var stopwatch = Stopwatch.StartNew(); await Assert.ThrowsAsync <HttpRequestException>(() => retryPolicy.ExecuteAsync(client.SendRequest)); stopwatch.Stop(); Assert.True(client.TimesCalled > 1); var maximumPossibleNextWaitTime = 1.2 * options.DeltaBackoff * Math.Pow(2, client.TimesCalled - 1); Assert.True(stopwatch.Elapsed > options.MaxCumulativeWaitTime - maximumPossibleNextWaitTime); }
public async Task ExecuteAsync_UnsuccessfulStatusCode_RetriesUntilCumulativeWaitTimeReached() { var options = new DefaultRetryPolicyOptions { DeltaBackoff = TimeSpan.FromMilliseconds(100), MaxCumulativeWaitTime = TimeSpan.FromSeconds(2) }; var retryPolicy = new DefaultRetryPolicy(options); var client = new FakeSender().Returns(HttpStatusCode.InternalServerError); var stopwatch = Stopwatch.StartNew(); var response = await retryPolicy.ExecuteAsync(client.SendRequest); stopwatch.Stop(); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.True(client.TimesCalled > 1); var maximumPossibleNextWaitTime = 1.2 * options.DeltaBackoff * Math.Pow(2, client.TimesCalled - 1); Assert.True(stopwatch.Elapsed > options.MaxCumulativeWaitTime - maximumPossibleNextWaitTime); }
public async Task <T> SendRequest <T>(string serviceUri, HttpRequestBase request) where T : HttpResponseBase, new() { if (typeof(T) == typeof(CreateRoomResponse)) { var roomId = _createRoomDelegate(_roomProperties, _gameApplication, ((CreateRoomRequest)request).RoomId); return(new CreateRoomResponse(roomId) as T); } if (typeof(T) == typeof(UpdateRoomResponse)) { var req = request as UpdateRoomRequest; _updateRoomDelegate(req.RoomId, _gameApplication); return(new UpdateRoomResponse() as T); } if (typeof(T) == typeof(GetServerInfoListResponse)) { return(FakeSender.CreateGetServerInfoListResponse <T>() as T); } ; return(new T()); }
public void NetworkControllerConnectToMulticastGroup() { NetworkController nc = new NetworkController(); FakeServer server = new FakeServer(); FakeSender sender = new FakeSender(); nc.Servers.Add(server); Networking.NetworkController = nc; Networking.Start(); SenderBase.FactoryMethod = e => sender; MulticastRemoteSubscriptionhandle h = new MulticastRemoteSubscriptionhandle(); Networking.ConnectToMulticast(h.IpAddress, h.Port); TestSubscriber s = new TestSubscriber(); s.Subscribe(); Assert.IsTrue(server._connectedToMulticastGroup); }