public void TestTimingThousandCalls() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); using (server) { JsonRpcRequest request = new JsonRpcRequest { Method = "test:channel", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; Stopwatch sw = new Stopwatch(); sw.Start(); for (int i = 0; i < 1000; i++) { var resp = server.ServeAsync(request).GetAwaiter().GetResult(); Assert.IsNotNull(resp); Assert.IsNull(resp.Error); Assert.AreEqual(request.Id.ToString(), resp.Id); Assert.AreEqual("ping", resp.Result); } sw.Stop(); Console.WriteLine($"Elapsed Time:{sw.Elapsed}"); } }
public CreateData() { var baseOptions = new JsonRpcServerOptions().WithPipe(new Pipe()); void BaseDelegate(JsonRpcServerOptions o) { o.WithPipe(new Pipe()); } var serviceProvider = new ServiceCollection().BuildServiceProvider(); Add(new ActionDelegate("create: options", () => JsonRpcServer.Create(baseOptions))); Add(new ActionDelegate("create: options, serviceProvider", () => JsonRpcServer.Create(baseOptions, serviceProvider))); Add(new ActionDelegate("create: action", () => JsonRpcServer.Create(BaseDelegate))); Add(new ActionDelegate("create: action, serviceProvider", () => JsonRpcServer.Create(BaseDelegate, serviceProvider))); Add(new ActionDelegate("from: options", () => JsonRpcServer.From(baseOptions))); Add(new ActionDelegate("from: options, cancellationToken", () => JsonRpcServer.From(baseOptions, CancellationToken.None))); Add(new ActionDelegate("from: options, serviceProvider, cancellationToken", () => JsonRpcServer.From(baseOptions, serviceProvider, CancellationToken.None))); Add(new ActionDelegate("from: options, serviceProvider", () => JsonRpcServer.From(baseOptions, serviceProvider))); Add(new ActionDelegate("from: action", () => JsonRpcServer.From(BaseDelegate))); Add(new ActionDelegate("from: action, cancellationToken", () => JsonRpcServer.From(BaseDelegate, CancellationToken.None))); Add(new ActionDelegate("from: action, serviceProvider, cancellationToken", () => JsonRpcServer.From(BaseDelegate, serviceProvider, CancellationToken.None))); Add(new ActionDelegate("from: action, serviceProvider", () => JsonRpcServer.From(BaseDelegate, serviceProvider))); }
public void TestExceptionInJsonRpcShouldReturnInternalError() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 10000); using (server) { JsonRpcRequest request = new JsonRpcRequest { Method = "test:exception", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; var resp = server.ServeAsync(request).GetAwaiter().GetResult(); Assert.IsNotNull(resp); Assert.AreEqual(request.Id.ToString(), resp.Id); Assert.IsNull(resp.Result); Assert.IsNotNull(resp.Error); Assert.AreEqual((int)ErrorCode.InternalError, resp.Error.Code); Assert.AreEqual("Error", resp.Error.Message); } }
public void ReturnStringArray() { Response <object> reply = default; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response <object>)o); var reqOring = new Request() { Id = 3, Method = "ReturnStringArray" }; var json = Serializer.Serialize(reqOring); var req = Serializer.Deserialize <Request>(json); server.Bind(handler); server.ExecuteHandler(clientMock.Object, req.Id, req.Method, req.Params); reply.Should().NotBeNull(); reply.Id.Should().Be(3); reply.Error.Should().BeNull(); reply.Result.Should().BeEquivalentTo(new string[] { "one", "two", "three" }); }
public void Call_GivenDateTime() { Response reply = default; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response)o); var now = DateTime.Now; var reqOring = new Request() { Id = 81, Method = "DateTimeTest", Params = new object[] { now } }; var json = Serializer.Serialize(reqOring); var req = Serializer.Deserialize <Request>(json); server.Bind(handler); server.ExecuteHandler(clientMock.Object, req.Id, req.Method, req.Params); reply.Should().NotBeNull(); reply.Id.Should().Be(81); reply.Error.Should().BeNull(); }
public void TestNatSubscriptionShouldLogPublishingError() { var mockLogger = new Mock <Microsoft.Extensions.Logging.ILogger>(); JsonRpcSubscription subscription = new JsonRpcSubscription("test:largepayload", "test::group", new LargePayloadService(), mockLogger.Object); subscription.Subscribe("nats://127.0.0.1"); subscription.Start().GetAwaiter().GetResult(); JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); using (server) { Assert.Throws <JsonRpcException>(() => { var resp = server.ServeAsync(new JsonRpcRequest { Method = "test:largepayload", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "size", "10000000" } } }).GetAwaiter().GetResult(); }); } mockLogger.Verify(m => m.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <Object>(), It.IsAny <Exception>(), It.IsAny <Func <Object, Exception, string> >())); }
public void TestMultipleConcurrentCallsShouldNotThrowException() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); List <Task> tasks = new List <Task>(); for (int i = 0; i < 10; i++) { var task = Task.Run(() => { JsonRpcRequest request = new JsonRpcRequest { Method = "test:channel", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; //server.ServeAsync(request).GetAwaiter().GetResult(); }); tasks.Add(task); } Assert.DoesNotThrow(() => { Task.WaitAll(tasks.ToArray()); }); server.Dispose(); }
public void CanInvokeDelegate_WithArgs_ReturnValue() { Response <object> reply = default; var fakePipe = new StreamDuplexPipe(PipeOptions.Default, new MemoryStream()); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response <object>)o); bool called = false; server.Bind("DelegateFunction", (Func <int, string, string>)((a, b) => { called = b == "TestString"; return(b); })); server.ExecuteHandler(clientMock.Object, 21, "DelegateFunction", new object[] { 176, "TestString" }); called.Should().BeTrue(); reply.Should().NotBeNull(); reply.Error.Should().BeNull(); reply.Id.Should().Be(21); reply.Result.Should().NotBeNull(); reply.Result.Should().Be("TestString"); }
public JsonRpcIntegrationTestBase(ITestOutputHelper output) { this.output = output; var configs = new JsonRpcServerConfigurations() { BindingPort = port, //Interlocked.Increment(ref port), TransportProtocol = JsonRpcServerConfigurations.TransportMode.Bson }; server = new JsonRpcServer<TestActionHandler>(configs); client = JsonRpcClient<TestActionHandler>.CreateClient("localhost", server.Configurations.BindingPort, JsonRpcServerConfigurations.TransportMode.Bson); client.Info.Username = "******"; client.OnAuthenticationRequest += (sender, e) => { e.Data = AUTH_TEXT; }; server.OnAuthenticationVerification += (sender, e) => { e.Authenticated = true; }; server.OnStop += (sender, e) => { wait.Set(); }; }
/// <summary> /// Start the debug server listening. /// </summary> /// <returns>A task that completes when the server is ready.</returns> public async Task StartAsync() { _jsonRpcServer = await JsonRpcServer.From(options => { options.Serializer = new DapProtocolSerializer(); options.Receiver = new DapReceiver(); options.LoggerFactory = _loggerFactory; ILogger logger = options.LoggerFactory.CreateLogger("DebugOptionsStartup"); // We need to let the PowerShell Context Service know that we are in a debug session // so that it doesn't send the powerShell/startDebugger message. _powerShellContextService = ServiceProvider.GetService <PowerShellContextService>(); _powerShellContextService.IsDebugServerActive = true; // Needed to make sure PSReadLine's static properties are initialized in the pipeline thread. // This is only needed for Temp sessions who only have a debug server. if (_usePSReadLine && _useTempSession && Interlocked.Exchange(ref s_hasRunPsrlStaticCtor, 1) == 0) { // This must be run synchronously to ensure debugging works _powerShellContextService .ExecuteScriptStringAsync("[System.Runtime.CompilerServices.RuntimeHelpers]::RunClassConstructor([Microsoft.PowerShell.PSConsoleReadLine].TypeHandle)") .GetAwaiter() .GetResult(); } options.Services = new ServiceCollection() .AddPsesDebugServices(ServiceProvider, this, _useTempSession); options .WithInput(_inputStream) .WithOutput(_outputStream); logger.LogInformation("Adding handlers"); options .WithHandler <InitializeHandler>() .WithHandler <LaunchHandler>() .WithHandler <AttachHandler>() .WithHandler <DisconnectHandler>() .WithHandler <SetFunctionBreakpointsHandler>() .WithHandler <SetExceptionBreakpointsHandler>() .WithHandler <ConfigurationDoneHandler>() .WithHandler <ThreadsHandler>() .WithHandler <SetBreakpointsHandler>() .WithHandler <StackTraceHandler>() .WithHandler <ScopesHandler>() .WithHandler <VariablesHandler>() .WithHandler <ContinueHandler>() .WithHandler <NextHandler>() .WithHandler <PauseHandler>() .WithHandler <StepInHandler>() .WithHandler <StepOutHandler>() .WithHandler <SourceHandler>() .WithHandler <SetVariableHandler>() .WithHandler <DebugEvaluateHandler>(); logger.LogInformation("Handlers added"); }).ConfigureAwait(false); }
public static string[] ListMethods(JsonRpcServer server) { var methods = server.Methods .Select(m => m.Name) .ToArray(); return(methods); }
static void Main(string[] args) { ThreadPool.SetMinThreads(65535, 65535); var server = new JsonRpcServer(); var client = new JsonRpcClient(); if (args.Contains("-debug")) { Logger.DebugMode = true; Logger.UseDefaultWriter(); } if (args.Contains("-benchmark")) { var engine = new JsonRpcInProcessEngine(); server.UseEngine(engine); client.UseEngine(engine); server.Start(); var statisticsList = new List <int>(); for (var i = 0; i < 20; i++) { statisticsList.Add(Benchmark(client, TestData)); Console.WriteLine(); } Console.WriteLine(); Console.WriteLine($"Best: {statisticsList.Max()} rpc/sec, \t Average: {(int)statisticsList.Average()} rpc/sec, \t Worst: {statisticsList.Min()} rpc/sec"); } else { IJsonRpcServerEngine serverEngine; if (args.Contains("-websocket")) { serverEngine = new JsonRpcWebSocketServerEngine("http://*:8090/"); server.UseEngine(serverEngine); } else if (args.Contains("-websocket-kestrel")) { serverEngine = new JsonRpcKestrelWebSocketServerEngine(IPAddress.Any, 8090); server.UseEngine(serverEngine); } else if (args.Contains("-http-kestrel")) { serverEngine = new JsonRpcKestrelHttpServerEngine(IPAddress.Any, 8090); server.UseEngine(serverEngine); } else { serverEngine = new JsonRpcHttpServerEngine("http://*:8090/"); server.UseEngine(serverEngine); } server.Start(); Console.WriteLine($"JsonRpc Server Started with engine: {serverEngine.Name}."); } Console.ReadLine(); }
protected virtual async Task <(JsonRpcServer client, JsonRpcServer server)> Initialize( Action <JsonRpcServerOptions> clientOptionsAction, Action <JsonRpcServerOptions> serverOptionsAction ) { var clientPipe = new Pipe(TestOptions.DefaultPipeOptions); var serverPipe = new Pipe(TestOptions.DefaultPipeOptions); var clientTask = JsonRpcServer.From( options => { options .WithLoggerFactory(TestOptions.ClientLoggerFactory) .WithServices( services => services .AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>)) .AddSingleton(ClientEvents as IRequestSettler) .AddLogging( x => { x.SetMinimumLevel(LogLevel.Trace); } ) ); ConfigureClientInputOutput(serverPipe.Reader, clientPipe.Writer, options); clientOptionsAction(options); }, CancellationToken ); var serverTask = JsonRpcServer.From( options => { options .WithServices( services => services .AddTransient(typeof(IPipelineBehavior <,>), typeof(SettlePipeline <,>)) .AddSingleton(ServerEvents as IRequestSettler) .AddLogging( x => { x.SetMinimumLevel(LogLevel.Trace); x.Services.AddSingleton(TestOptions.ServerLoggerFactory); } ) ); ConfigureServerInputOutput(clientPipe.Reader, serverPipe.Writer, options); serverOptionsAction(options); }, CancellationToken ); await Task.WhenAll(clientTask, serverTask).ConfigureAwait(false); #pragma warning disable VSTHRD103 _client = clientTask.Result; _server = serverTask.Result; #pragma warning restore VSTHRD103 Disposable.Add(_client); Disposable.Add(_server); return(_client, _server); }
public TestRpcClient() { var glue = new MockService(); var listener = new JsonRpcServer(glue); listener.Register <RpcTargetMock>(); listener.Start(); _client = new JsonRpcClient(glue); }
public void TestTypeRegistration() { using (new AssertionScope()) using (var listener = new JsonRpcServer(new MockService())) { listener.Register(typeof(RpcTargetMock)); var registry = listener.GetRegisteredMethods(); registry.Should().Contain("Canary"); } }
public async Task StartAsync(IServiceProvider languageServerServiceProvider, bool useTempSession) { _jsonRpcServer = await JsonRpcServer.From(options => { options.Serializer = new DapProtocolSerializer(); options.Reciever = new DapReciever(); options.LoggerFactory = _loggerFactory; ILogger logger = options.LoggerFactory.CreateLogger("DebugOptionsStartup"); // We need to let the PowerShell Context Service know that we are in a debug session // so that it doesn't send the powerShell/startDebugger message. _powerShellContextService = languageServerServiceProvider.GetService <PowerShellContextService>(); _powerShellContextService.IsDebugServerActive = true; // Needed to make sure PSReadLine's static properties are initialized in the pipeline thread. _powerShellContextService .ExecuteScriptStringAsync("[System.Runtime.CompilerServices.RuntimeHelpers]::RunClassConstructor([Microsoft.PowerShell.PSConsoleReadLine].TypeHandle)") .Wait(); options.Services = new ServiceCollection() .AddPsesDebugServices(languageServerServiceProvider, this, useTempSession); options .WithInput(_inputStream) .WithOutput(_outputStream); logger.LogInformation("Adding handlers"); options .WithHandler <InitializeHandler>() .WithHandler <LaunchHandler>() .WithHandler <AttachHandler>() .WithHandler <DisconnectHandler>() .WithHandler <SetFunctionBreakpointsHandler>() .WithHandler <SetExceptionBreakpointsHandler>() .WithHandler <ConfigurationDoneHandler>() .WithHandler <ThreadsHandler>() .WithHandler <SetBreakpointsHandler>() .WithHandler <StackTraceHandler>() .WithHandler <ScopesHandler>() .WithHandler <VariablesHandler>() .WithHandler <ContinueHandler>() .WithHandler <NextHandler>() .WithHandler <PauseHandler>() .WithHandler <StepInHandler>() .WithHandler <StepOutHandler>() .WithHandler <SourceHandler>() .WithHandler <SetVariableHandler>() .WithHandler <DebugEvaluateHandler>(); logger.LogInformation("Handlers added"); }); }
public void NoReturnOnNotify() { string reply = null; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteString(It.IsAny <string>())).Callback <string>(s => reply = s); server.Bind(handler); server.ExecuteHandler(clientMock.Object, -1, "ReturnStringArray", null); reply.Should().BeNull(); }
public MissingOutputData() { var baseOptions = new JsonRpcServerOptions().WithInput(new Pipe().Reader); void BaseDelegate(JsonRpcServerOptions o) { o.WithInput(new Pipe().Reader); } var serviceProvider = new ServiceCollection().BuildServiceProvider(); Add(new ActionDelegate("create: options", () => JsonRpcServer.Create(baseOptions))); Add(new ActionDelegate("create: options, serviceProvider", () => JsonRpcServer.Create(baseOptions, serviceProvider))); Add(new ActionDelegate("create: action", () => JsonRpcServer.Create(BaseDelegate))); Add(new ActionDelegate("create: action, serviceProvider", () => JsonRpcServer.Create(BaseDelegate, serviceProvider))); }
public void Awake() { SceneDumpService = new SceneDumpService(new RuntimeObjectWrapperService()); Processor = new JsonRpcProcessor(); QueryService = new SceneQueryService(); LuaRuntime = new DefaultUnitiniumLuaRuntime(QueryService); Processor.SetMethod("dump", SceneDumpService.DumpScenes); Processor.SetMethod("execute", (string script) => LuaRuntime.Execute(script)); Processor.SetMethod("co_execute", (string script) => LuaRuntime.Execute(script, true)); Processor.SetMethod("get_execution", (long id) => LuaRuntime.GetExecution((int)id)); Processor.SetMethod("query", (string query) => QueryService.Execute(query)); server = new JsonRpcServer(); requests = server.Start("http://localhost:" + ListenPort + "/"); }
public void Call_WithDefaultArgsValues() { Response reply = default; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response)o); server.Bind(handler); server.ExecuteHandler(clientMock.Object, 31, "DefaultArgs", new object[] { 123 }); reply.Should().NotBeNull(); reply.Id.Should().Be(31); reply.Error.Should().BeNull(); }
public void TestDisposedServiceThrowsException() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); server.Dispose(); JsonRpcRequest request = new JsonRpcRequest { Method = "test:channel", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; Assert.Throws <ObjectDisposedException>(() => server.Serve(request)); }
public void Call_GivenTypesArgs() { Response <object> reply = default; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response <object>)o); server.Bind(handler); server.ExecuteHandler(clientMock.Object, 1, "FirstTest", new object[] { 1, "string", false, null }); reply.Should().NotBeNull(); reply.Id.Should().Be(1); reply.Result.Should().Be(23); }
public void Call_StaticFunction() { Response reply = default; var fakePipe = new StreamDuplexPipe(PipeOptions.Default, new MemoryStream()); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response)o); server.Bind(typeof(StaticHandler)); server.ExecuteHandler(clientMock.Object, 43, "Function1", null); reply.Should().NotBeNull(); reply.Error.Should().BeNull(); }
public JsonRpcContext(IServiceProvider requestServices, JsonRpcServer server, JsonRpcRequest request) { if (requestServices == null) { throw new ArgumentNullException(nameof(requestServices)); } if (server == null) { throw new ArgumentNullException(nameof(server)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } RequestServices = requestServices; Server = server; Request = request; }
public void TestTypeRegistrationExplicit() { using (new AssertionScope()) using (var listener = new JsonRpcServer(new MockService())) { listener.Register(typeof(RpcTargetMock), "Canary"); listener.Register(typeof(RpcTargetMock), "Echo", "Pizza"); var registry = listener.GetRegisteredMethods(); registry.Should().Contain("Canary"); registry.Should().Contain("Pizza"); // ReSharper disable once AccessToDisposedClosure Action testAction = () => listener.Register(typeof(RpcTargetMock), "thisIsNotAValidMethod"); testAction.Should().Throw <RpcRegistrationException>(); } }
static void Main(string[] args) { Console.WriteLine("JSON RPC SimpleServer\n"); _server = new JsonRpcServer(); _listener = new TcpListener(IPAddress.Any, 11000); _listener.Start(); // Accept first client connection _listener.BeginAcceptTcpClient(AcceptClient, null); Console.WriteLine($"Listening on port 11000"); Console.WriteLine("Press ENTER to stop\n"); Console.ReadLine(); _listener.Stop(); _server.Dispose(); }
public void TestCallUnknownMethodCallTimeout() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); using (server) { JsonRpcRequest request = new JsonRpcRequest { Method = "test:channel-unknown", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; Stopwatch sw = Stopwatch.StartNew(); Assert.Throws <JsonRpcException>(() => server.ServeAsync(request).GetAwaiter().GetResult()); sw.Stop(); Assert.IsTrue(sw.ElapsedMilliseconds >= 5000); } }
public void CanInvokeDelegate() { Response reply = default; var fakePipe = new StreamDuplexPipe(PipeOptions.Default, new MemoryStream()); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response)o); bool called = false; server.Bind("DelegateFunction", (Action)(() => { called = true; })); server.ExecuteHandler(clientMock.Object, 43, "DelegateFunction", null); called.Should().BeTrue(); reply.Should().NotBeNull(); reply.Error.Should().BeNull(); reply.Id.Should().Be(43); }
public void TestNatSubscriptionShouldRecoverFromPublishingError() { JsonRpcSubscription subscription = new JsonRpcSubscription("test:largepayload", "test::group", new LargePayloadService(), null); subscription.Subscribe("nats://127.0.0.1"); subscription.Start().GetAwaiter().GetResult(); JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); using (server) { Assert.Throws <JsonRpcException>(() => { var resp = server.ServeAsync(new JsonRpcRequest { Method = "test:largepayload", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "size", "10000000" } } }).GetAwaiter().GetResult(); }); var resp2 = server.ServeAsync(new JsonRpcRequest { Method = "test:largepayload", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "size", "100" } } }).GetAwaiter().GetResult(); Assert.IsNotNull(resp2); Assert.IsNull(resp2.Error); Assert.AreEqual(resp2.Id.ToString(), resp2.Id); Assert.AreEqual(new string('A', 100), resp2.Result); } }
public void TestCallMethodOverJsonRpc() { JsonRpcServer server = new JsonRpcServer("nats://127.0.0.1", 5000); using (server) { JsonRpcRequest request = new JsonRpcRequest { Method = "test:channel", Id = Guid.NewGuid().ToString(), Parameters = new Dictionary <string, string> { { "data", "ping" } } }; var resp = server.ServeAsync(request).GetAwaiter().GetResult(); Assert.IsNotNull(resp); Assert.IsNull(resp.Error); Assert.AreEqual(request.Id.ToString(), resp.Id); Assert.AreEqual("ping", resp.Result); } }
public void Call_GivenIntStringBoolNull() { Response <object> reply = default; var handler = new TestHandlerFake(); var server = new JsonRpcServer(); var clientMock = new Mock <JsonRpcServer.ClientConnection>(1, "localhost", _fakePipe, _process, Encoding.UTF8); clientMock.Setup(x => x.WriteAsJson(It.IsAny <object>())).Callback <object>(o => reply = (Response <object>)o); var reqOring = new Request() { Id = 1, Method = "FirstTest", Params = new object[] { 1, "string", false, null } }; var json = Serializer.Serialize(reqOring); var req = Serializer.Deserialize <Request>(json); server.Bind(handler); server.ExecuteHandler(clientMock.Object, req.Id, req.Method, req.Params); reply.Should().NotBeNull(); reply.Id.Should().Be(1); reply.Result.Should().Be(23); }
public async void Ping_does_not_time_out() { server.Configurations.PingFrequency = 250; server.Configurations.PingTimeoutDisconnectTime = 500; server = new JsonRpcServer<TestActionHandler>(server.Configurations); server.OnClientConnect += (sender, e) => { Task.Run(async () => { await Task.Delay(1000); if (e.Client.Info.Status == ClientStatus.Connected) { CompleteTest(); } else { FailTest(); } }); }; server.Start(); client.Connect(); await StartAndWaitClient(); }
public async void Ping_client_times_out() { server.Configurations.PingFrequency = 250; server.Configurations.PingTimeoutDisconnectTime = 500; server = new JsonRpcServer<TestActionHandler>(server.Configurations); server.OnClientConnect += (sender, e) => { // Make the remote client ignore all incoming requests. e.Client.OnDataReceived += (s2, e2) => { e2.Handled = true; }; }; server.OnClientDisconnect += (sender, e) => { CompleteTest(); }; server.Start(); client.Connect(); await StartAndWaitClient(); }