public ServerClientInteractionTest() { var clientCollection = new ServiceCollection(); clientCollection.AddLogging(); clientCollection .NetworkOperationClient <DefaultMessage, DefaultMessage>() .Serializer <MsgSerializer>() .Executor() .RuntimeModel(OperationRuntimeModel.CreateFromAttribute()) .Dispatcher <ExpressionDispatcher <DefaultMessage, DefaultMessage> >() .RegisterHandler <ClientOpHandler>(Scope.Session) .UseLiteNet(); _clientProvider = clientCollection.BuildServiceProvider(false); var hostCollection = new ServiceCollection(); hostCollection.AddLogging(); hostCollection.NetworkOperationHost <DefaultMessage, DefaultMessage>() .Executor() .Serializer <MsgSerializer>() .ConnectHandler <TestSessionRequestHandler>() .Dispatcher <ExpressionDispatcher <DefaultMessage, DefaultMessage> >() .RuntimeModel(OperationRuntimeModel.CreateFromAttribute()) .RegisterHandler <LongTimeOperationHandler>(Scope.Single) .RegisterHandler <MultiplayHandler>(Scope.Session) .RegisterHandler <PushTestHandler>(Scope.Session) .UseLiteNet(); _hostProvider = hostCollection.BuildServiceProvider(false); }
public async Task ManualDispatchTest() { var fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true }).Customize(new SupportMutableValueTypesCustomization()); var op = fixture.Create <A>(); var moqHandler = fixture.Freeze <Mock <IHandler <A, int, DefaultMessage> > >(); var result = fixture.Freeze <int>(); var factory = new Mock <IHandlerFactory>(); factory.Setup(f => f.Create <A, int, DefaultMessage>(It.IsAny <RequestContext <DefaultMessage> >())).ReturnsUsingFixture(fixture); var model = new OperationRuntimeModel(new[] { new OperationDescription(0, typeof(A), typeof(int), Side.Server, DeliveryMode.Ordered, DeliveryMode.Ordered, true), new OperationDescription(1, typeof(B), typeof(float), Side.Server, DeliveryMode.Ordered, DeliveryMode.Ordered, true) }); var dispatcher = new TestDispatcher(new MsgSerializer(), factory.Object, model, new NullLoggerFactory(), new DescriptionRuntimeModel()); dispatcher.Subscribe(new Mock <IResponseReceiver <DefaultMessage> >().Object); var hasData = true; var sessionMock = new Mock <Session>(Array.Empty <SessionProperty>()); sessionMock.SetupGet(s => s.HasAvailableData).Returns(() => hasData); sessionMock.Setup(s => s.ReceiveMessageAsync()).ReturnsAsync(() => { hasData = false; return(CreateRawMessage(0, op, TypeMessage.Request)); }); await dispatcher.DispatchAsync(sessionMock.Object); sessionMock.Verify(s => s.ReceiveMessageAsync(), Times.Once); moqHandler.Verify(handler => handler.Handle(op, It.IsAny <RequestContext <DefaultMessage> >(), It.IsAny <CancellationToken>()), Times.Once); }
public BaseDispatcher(BaseSerializer serializer, IHandlerFactory factory, OperationRuntimeModel model, ILoggerFactory logger, DescriptionRuntimeModel descriptionRuntimeModel) { _serializer = serializer; _factory = factory; Model = model; _descriptionRuntimeModel = descriptionRuntimeModel; Logger = logger.CreateLogger(GetType().FullName); }
public async Task DispatcherCancelTest() { var fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true }).Customize(new SupportMutableValueTypesCustomization()); var opFoo = fixture.Create <Foo>(); var fooHandler = new FooTestHandler(); var factory = new Mock <IHandlerFactory>(); factory.Setup(f => f.Create <Foo, int, DefaultMessage>(It.IsAny <RequestContext <DefaultMessage> >())).Returns(fooHandler); var generatedDispatcher = new ExpressionDispatcher <DefaultMessage, DefaultMessage>( new MsgSerializer(), factory.Object, OperationRuntimeModel.CreateFromAttribute(new[] { typeof(Foo) }), new NullLoggerFactory(), new DescriptionRuntimeModel()); generatedDispatcher.ExecutionSide = Side.Server; generatedDispatcher.Subscribe(new Mock <IResponseReceiver <DefaultMessage> >().Object); var mockSession = new Mock <Session>(Array.Empty <SessionProperty>()); var hasData = true; mockSession.SetupGet(s => s.HasAvailableData).Returns(() => hasData); mockSession.Setup(s => s.ReceiveMessageAsync()).ReturnsAsync(() => { hasData = false; return(CreateRawMessage(0, opFoo)); }); var hasCancelData = true; var mockSessionWithCancel = new Mock <Session>(Array.Empty <SessionProperty>()); mockSessionWithCancel.SetupGet(s => s.HasAvailableData).Returns(() => hasCancelData); mockSessionWithCancel.Setup(s => s.ReceiveMessageAsync()).ReturnsAsync(() => { hasCancelData = false; return(MessagePackSerializer.Serialize(new DefaultMessage() { OperationCode = 0, Status = BuiltInOperationState.Cancel })); }); generatedDispatcher.DispatchAsync(mockSession.Object).GetAwaiter(); Task.Delay(100).ContinueWith(task => { generatedDispatcher.DispatchAsync(mockSessionWithCancel.Object).GetAwaiter(); }).GetAwaiter(); await Task.Delay(300); mockSession.Verify(s => s.SendMessageAsync(It.IsAny <ArraySegment <byte> >(), DeliveryMode.Reliable | DeliveryMode.Ordered), Times.Never); mockSessionWithCancel.Verify(s => s.SendMessageAsync(It.IsAny <ArraySegment <byte> >(), DeliveryMode.Reliable | DeliveryMode.Ordered), Times.Never); mockSession.Verify(s => s.ReceiveMessageAsync(), Times.Once); mockSessionWithCancel.Verify(s => s.ReceiveMessageAsync(), Times.Once); }
public void CreateTest() { var model = OperationRuntimeModel.CreateFromAttribute(new[] { typeof(Op), typeof(Op2), typeof(Op4) }); var desc = model.GetDescriptionBy(0); Assert.Equal(typeof(Op), desc.OperationType); Assert.Equal(typeof(float), desc.ResultType); foreach (var d in model) { } }
public void must_client_configure() { var collection = new ServiceCollection(); collection.AddLogging(); collection .NetworkOperationClient <DefaultMessage, DefaultMessage>() .Serializer <MsgSerializer>() .Executor() .RuntimeModel(OperationRuntimeModel.CreateFromAttribute(new [] { typeof(Op) })) .Dispatcher <ExpressionDispatcher <DefaultMessage, DefaultMessage> >() .UseLiteNet(); var p = collection.BuildServiceProvider(); Assert.IsType <Client <DefaultMessage, DefaultMessage> >(p.GetRequiredService <IClient>()); }
private static void Generate(Options arg) { if (arg.AssemblyResolverPaths != null) { AssemblyLoadContext.Default.Resolving += (context, assemblyName) => { var assemblyPath = arg.AssemblyResolverPaths .Select(path => !Path.IsPathRooted(path) ? Path.Combine(Directory.GetCurrentDirectory(), path) : path) .Select(p => Path.Combine(p, assemblyName.Name + ".dll")) .FirstOrDefault(File.Exists); return(string.IsNullOrEmpty(assemblyPath) ? null : context.LoadFromAssemblyPath(assemblyPath)); }; } var model = OperationRuntimeModel.CreateFromAttribute(arg.AssemblyPaths.Select(Assembly.LoadFile)); Console.WriteLine($"Found operations:"); foreach (var description in model) { Console.WriteLine(description.OperationType.FullName); } var dispatcher = new PreGeneratedDispatcherTemplate { Session = new Dictionary <string, object>() { { "Model", model }, { "Side", arg.Side }, { "AOTSupport", arg.AOTSupport } } }; dispatcher.Initialize(); foreach (var error in dispatcher.Errors) { Console.WriteLine(error); } File.WriteAllText(Path.Combine(arg.Output, "PreGeneratedDispatcher.cs"), dispatcher.TransformText()); }
public void WrondEnumStatusType() { Assert.Throws <ArgumentException>(() => { OperationRuntimeModel.CreateFromAttribute(new[] { typeof(Op7) }); }); }
public void DuplicateTest() { Assert.Throws <ArgumentException>(() => { OperationRuntimeModel.CreateFromAttribute(new[] { typeof(Op), typeof(Op2), typeof(Op4), typeof(Op5), typeof(Op6) }); }); }
protected BaseOperationExecutor(OperationRuntimeModel model, BaseSerializer serializer, ILoggerFactory loggerFactory) { Model = model; _serializer = serializer; Logger = loggerFactory.CreateLogger(GetType().FullName); }
public DefaultClientOperationExecutorFactory(OperationRuntimeModel model, BaseSerializer serializer, ILoggerFactory loggerFactory) { _model = model; _serializer = serializer; _loggerFactory = loggerFactory; }
public TestDispatcher(BaseSerializer serializer, IHandlerFactory factory, OperationRuntimeModel model, ILoggerFactory logger, DescriptionRuntimeModel descriptionRuntimeModel) : base(serializer, factory, model, logger, descriptionRuntimeModel) { }
public Factory(OperationRuntimeModel model, BaseSerializer serializer, ILoggerFactory logger) { _model = model; _serializer = serializer; _logger = logger; }
public async Task ReceiveResultTest() { var serializeMock = new Mock <BaseSerializer>(); serializeMock.Setup(serializer => serializer.Deserialize <int>(It.IsAny <ArraySegment <byte> >(), It.IsAny <Session>())).Returns(111); serializeMock.Setup(serializer => serializer.Serialize(It.IsAny <A>(), It.IsAny <Session>())).Returns(new byte[10]); var executor = new HostOperationExecutor <DefaultMessage, DefaultMessage>(OperationRuntimeModel.CreateFromAttribute(new[] { typeof(A) }), serializeMock.Object, new Mock <SessionCollection>().Object, new NullLoggerFactory()); var mockGenerator = new Mock <IGeneratorId>(); mockGenerator.Setup(id => id.Generate()).Returns(100); executor.MessageIdGenerator = mockGenerator.Object; IResponseReceiver <DefaultMessage> e = executor; Task.Delay(100).ContinueWith(_ => e.Receive(new DefaultMessage() { OperationCode = 0, Status = BuiltInOperationState.Success, OperationData = new byte[10], Id = 100 })) .GetAwaiter(); var result = await executor.Execute <A, int>(new A()); Assert.Equal(111, result.Result); }
public void ExecuteTest() { var serializeMock = new Mock <BaseSerializer>(); var mockSession = new Mock <SessionCollection>(); var mockSetting = new HostOperationExecutor <DefaultMessage, DefaultMessage>(OperationRuntimeModel.CreateFromAttribute(new [] { typeof(A) }), serializeMock.Object, mockSession.Object, new NullLoggerFactory()); var task = mockSetting.Execute <A, int>(new A()); Assert.Equal(TaskStatus.WaitingForActivation, task.Status); mockSession.Verify(c => c.SendToAllAsync(It.IsAny <ArraySegment <byte> >(), It.IsAny <DeliveryMode>()), Times.Once); serializeMock.Verify(serializer => serializer.Serialize(It.IsAny <A>(), It.IsAny <Session>()), Times.Once); }
public async Task GeneratedDispatchTest() { var fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true }).Customize(new SupportMutableValueTypesCustomization()); var opA = fixture.Create <A>(); var opB = fixture.Create <B>(); var resultA = fixture.Freeze <int>(); var handlerA = fixture.Freeze <Mock <IHandler <A, int, DefaultMessage> > >(); var handlerB = fixture.Freeze <Mock <IHandler <B, float, DefaultMessage> > >(); var factory = new Mock <IHandlerFactory>(); factory.Setup(f => f.Create <A, int, DefaultMessage>(It.IsAny <RequestContext <DefaultMessage> >())).ReturnsUsingFixture(fixture); factory.Setup(f => f.Create <B, float, DefaultMessage>(It.IsAny <RequestContext <DefaultMessage> >())).ReturnsUsingFixture(fixture); var generatedDispatcher = new ExpressionDispatcher <DefaultMessage, DefaultMessage>(new MsgSerializer(), factory.Object, OperationRuntimeModel.CreateFromAttribute(new[] { typeof(A), typeof(B) }), new NullLoggerFactory(), new DescriptionRuntimeModel()); generatedDispatcher.ExecutionSide = Side.Server; generatedDispatcher.Subscribe(new Mock <IResponseReceiver <DefaultMessage> >().Object); var mockSession = new Mock <Session>(Array.Empty <SessionProperty>()); var hasData = true; mockSession.SetupGet(s => s.HasAvailableData).Returns(() => hasData); mockSession.Setup(s => s.ReceiveMessageAsync()).ReturnsAsync(() => { hasData = false; return(CreateRawMessage(0, opA, TypeMessage.Request)); }); await generatedDispatcher.DispatchAsync(mockSession.Object); mockSession.Verify(s => s.SendMessageAsync(It.IsAny <ArraySegment <byte> >(), DeliveryMode.Reliable | DeliveryMode.Ordered), Times.Once); handlerA.Verify(handler => handler.Handle(opA, It.IsAny <RequestContext <DefaultMessage> >(), It.IsAny <CancellationToken>()), Times.Once); handlerB.Verify(h => h.Handle(It.IsAny <B>(), It.IsAny <RequestContext <DefaultMessage> >(), It.IsAny <CancellationToken>()), Times.Never); }
public HostOperationExecutor(OperationRuntimeModel model, BaseSerializer serializer, SessionCollection sessions, ILoggerFactory loggerFactory) : base(model, serializer, loggerFactory) { _sessions = sessions; }
public void ExecutorCancelTest() { var serializeMock = new Mock <BaseSerializer>(); var mockSession = new Mock <SessionCollection>(); var mockSetting = new HostOperationExecutor <DefaultMessage, DefaultMessage>(OperationRuntimeModel.CreateFromAttribute(new [] { typeof(Foo) }), serializeMock.Object, mockSession.Object, new NullLoggerFactory()); var cts = new CancellationTokenSource(); var task = mockSetting.Execute <Foo, int>(new Foo(), cts.Token); cts.Cancel(); Assert.Equal(TaskStatus.Canceled, task.Status); mockSession.Verify(c => c.SendToAllAsync(It.IsAny <ArraySegment <byte> >(), DeliveryMode.Reliable | DeliveryMode.Ordered), Times.Exactly(2)); }
public TImplement RuntimeModel(OperationRuntimeModel model) { Service.Add(ServiceDescriptor.Singleton(typeof(OperationRuntimeModel), model)); return(This); }
public DefaultClientOperationExecutor(OperationRuntimeModel model, BaseSerializer serializer, Session session, ILoggerFactory loggerFactory) : base(model, serializer, loggerFactory) { _session = session; }