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;
}
