From d7af18acf1c3d312ad72abcbe6d70ab1324f9f85 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 17:09:14 +0600 Subject: [PATCH 01/13] fix: remove WebHttp - it just doesnt work --- SpaceBattle.Lib.Tests/EndPointTests.cs | 169 ------------------ .../SpaceBattle.Lib.Tests.csproj | 1 - WebHttp/Endpoint.cs | 16 -- WebHttp/IWebApi.cs | 19 -- WebHttp/MessageContract.cs | 29 --- WebHttp/Program.cs | 22 --- WebHttp/Startup.cs | 50 ------ WebHttp/WebHttp.csproj | 21 --- spacebattle.sln | 2 - 9 files changed, 329 deletions(-) delete mode 100644 SpaceBattle.Lib.Tests/EndPointTests.cs delete mode 100644 WebHttp/Endpoint.cs delete mode 100644 WebHttp/IWebApi.cs delete mode 100644 WebHttp/MessageContract.cs delete mode 100644 WebHttp/Program.cs delete mode 100644 WebHttp/Startup.cs delete mode 100644 WebHttp/WebHttp.csproj diff --git a/SpaceBattle.Lib.Tests/EndPointTests.cs b/SpaceBattle.Lib.Tests/EndPointTests.cs deleted file mode 100644 index baf45f0..0000000 --- a/SpaceBattle.Lib.Tests/EndPointTests.cs +++ /dev/null @@ -1,169 +0,0 @@ -using System.Collections.Concurrent; -using Hwdtech; -using Hwdtech.Ioc; -using Moq; -using WebHttp; - -namespace SpaceBattle.Lib.Tests; - -public class EndpointTests -{ - public EndpointTests() - { - new InitScopeBasedIoCImplementationCommand().Execute(); - - IoC.Resolve( - "Scopes.Current.Set", - IoC.Resolve("Scopes.New", - IoC.Resolve("Scopes.Root") - ) - ).Execute(); - } - - [Fact] - public void EndpointWorksSuccessfuly() - { - var ThreadId = 1; - - IoC.Resolve( - "IoC.Register", - "SearchThreadIdByGameId", - (object[] args) => { return (object)ThreadId; }).Execute(); - - var message = new MessageContract() - { - TypeCommand = "rotate", - GameId = "1", - ObjectId = "1", - Proprties = new Dictionary() { { "AngleVelocity", 1 } } - }; - - var cmd = new Mock(); - - IoC.Resolve( - "IoC.Register", - "ICommand Message", - (object[] args) => - { - return cmd.Object; - } - ).Execute(); - - var q = new BlockingCollection(); - - IoC.Resolve( - "IoC.Register", - "Endpoint.Commands.SendCommand", - (object[] args) => - { - var cmd = new ActionCommand(() => - { - q.Add((ICommand)args[1]); - }); - return cmd; - } - ).Execute(); - - var wa = new Endpoint(); - - wa.BodyEcho(message); - - Assert.Single(q); - } - - [Fact] - public void EndpointWorksWhithExceptionInJson() - { - var ThreadId = 1; - - IoC.Resolve( - "IoC.Register", - "SearchThreadIdByGameId", - (object[] args) => { return (object)ThreadId; }).Execute(); - - var cmd = new Mock(); - - IoC.Resolve( - "IoC.Register", - "ICommand Message", - (object[] args) => - { - return cmd.Object; - } - ).Execute(); - - var q = new BlockingCollection(); - - IoC.Resolve( - "IoC.Register", - "Endpoint.Commands.SendCommand", - (object[] args) => - { - var cmd = new ActionCommand(() => - { - throw new Exception(); - }); - return cmd; - } - ).Execute(); - - var message = new Mock(); - - var wa = new Endpoint(); - - var exception_com = new ActionCommand(() => - { - wa.BodyEcho(message.Object); - }); - - Assert.Throws(exception_com.Execute); - } - - [Fact] - public void EndpointWorksWhithExceptionInId() - { - var ThreadId = new Exception(); - - IoC.Resolve( - "IoC.Register", - "SearchThreadIdByGameId", - (object[] args) => { return (object)ThreadId; }).Execute(); - - var cmd = new Mock(); - - IoC.Resolve( - "IoC.Register", - "ICommand Message", - (object[] args) => - { - return cmd.Object; - } - ).Execute(); - - var q = new BlockingCollection(); - - IoC.Resolve( - "IoC.Register", - "Endpoint.Commands.SendCommand", - (object[] args) => - { - var cmd = new ActionCommand(() => - { - q.Add((ICommand)args[1]); - }); - return cmd; - } - ).Execute(); - - var message = new Mock(); - - var wa = new Endpoint(); - - var exception_com = new ActionCommand(() => - { - wa.BodyEcho(message.Object); - }); - - Assert.Throws(exception_com.Execute); - } -} diff --git a/SpaceBattle.Lib.Tests/SpaceBattle.Lib.Tests.csproj b/SpaceBattle.Lib.Tests/SpaceBattle.Lib.Tests.csproj index 7f4f678..9da4fcd 100644 --- a/SpaceBattle.Lib.Tests/SpaceBattle.Lib.Tests.csproj +++ b/SpaceBattle.Lib.Tests/SpaceBattle.Lib.Tests.csproj @@ -31,7 +31,6 @@ - diff --git a/WebHttp/Endpoint.cs b/WebHttp/Endpoint.cs deleted file mode 100644 index dbdf586..0000000 --- a/WebHttp/Endpoint.cs +++ /dev/null @@ -1,16 +0,0 @@ -using CoreWCF; -using Hwdtech; -using System; - -namespace WebHttp -{ - [ServiceBehavior(IncludeExceptionDetailInFaults = true)] - public class Endpoint : IWebApi - { - public void BodyEcho(MessageContract message) - { - var ThreadId = (int)IoC.Resolve("SearchThreadIdByGameId", message.GameId); - IoC.Resolve("Endpoint.Commands.SendCommand", ThreadId, IoC.Resolve("ICommand Message", message)).Execute(); - } - } -} diff --git a/WebHttp/IWebApi.cs b/WebHttp/IWebApi.cs deleted file mode 100644 index 65a3943..0000000 --- a/WebHttp/IWebApi.cs +++ /dev/null @@ -1,19 +0,0 @@ -using System.Net; -using CoreWCF; -using CoreWCF.OpenApi.Attributes; -using CoreWCF.Web; - -namespace WebHttp -{ - [ServiceContract] - [OpenApiBasePath("/api")] - public interface IWebApi - { - [OperationContract] - [WebInvoke(Method = "POST", UriTemplate = "/body")] - [OpenApiTag("Tag")] - [OpenApiResponse(ContentTypes = new[] { "application/json", "text/xml" }, Description = "Success", StatusCode = HttpStatusCode.Accepted, Type = typeof(MessageContract))] - void BodyEcho( - [OpenApiParameter(ContentTypes = new[] { "application/json", "text/xml" }, Description = "param description.")] MessageContract param); - } -} diff --git a/WebHttp/MessageContract.cs b/WebHttp/MessageContract.cs deleted file mode 100644 index 3c732c9..0000000 --- a/WebHttp/MessageContract.cs +++ /dev/null @@ -1,29 +0,0 @@ -using System.Collections.Generic; -using System.Runtime.Serialization; -using CoreWCF.OpenApi.Attributes; -using System.Collections.Concurrent; -using System.Diagnostics.CodeAnalysis; - -namespace WebHttp -{ - [DataContract(Name = "ExampleContract", Namespace = "http://example.com")] - [ExcludeFromCodeCoverage] - public class MessageContract - { - [DataMember(Name = "Type of command", Order = 1)] - [OpenApiProperty(Description = "Type of command description.")] - public required string TypeCommand { get; set; } - - [DataMember(Name = "Game Id", Order = 2)] - [OpenApiProperty(Description = "Game Id description.")] - public required string GameId { get; set; } - - [DataMember(Name = "Id of object in game", Order = 3)] - [OpenApiProperty(Description = "Id of object in game description.")] - public required string ObjectId { get; set; } - - [DataMember(Name = "Proprties", Order = 4)] - [OpenApiProperty(Description = "Proprties description.")] - public IDictionary Proprties { get; set; } - } -} diff --git a/WebHttp/Program.cs b/WebHttp/Program.cs deleted file mode 100644 index 7c99180..0000000 --- a/WebHttp/Program.cs +++ /dev/null @@ -1,22 +0,0 @@ -using Microsoft.AspNetCore; -using Microsoft.AspNetCore.Builder; -using Microsoft.AspNetCore.Hosting; -using System.Net; -using System.Diagnostics.CodeAnalysis; - -[ExcludeFromCodeCoverage] -class Program() -{ - static void Main(string[] args) - { - IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args) - .UseKestrel(options => - { - options.ListenAnyIP(8080); - }) - .UseStartup(); - - IWebHost app = builder.Build(); - app.Run(); - } -} diff --git a/WebHttp/Startup.cs b/WebHttp/Startup.cs deleted file mode 100644 index 0c9c467..0000000 --- a/WebHttp/Startup.cs +++ /dev/null @@ -1,50 +0,0 @@ -using CoreWCF; -using CoreWCF.Configuration; -using Microsoft.AspNetCore.Builder; -using Microsoft.Extensions.DependencyInjection; -using Swashbuckle.AspNetCore.Swagger; -using System.Xml; -using WebHttp; -using System.Diagnostics.CodeAnalysis; - -[ExcludeFromCodeCoverage] -internal sealed class Startup -{ - public void ConfigureServices(IServiceCollection services) - { - services.AddServiceModelWebServices(o => - { - o.Title = "Test API"; - o.Version = "1"; - o.Description = "API Description"; - o.TermsOfService = new("http://example.com/terms"); - o.ContactName = "Contact"; - o.ContactEmail = "support@example.com"; - o.ContactUrl = new("http://example.com/contact"); - o.ExternalDocumentUrl = new("http://example.com/doc.pdf"); - o.ExternalDocumentDescription = "Documentation"; - }); - - services.AddSingleton(new SwaggerOptions()); - } - - public void Configure(IApplicationBuilder app) - { - app.UseMiddleware(); - app.UseSwaggerUI(); - - app.UseServiceModel(builder => - { - builder.AddService(); - builder.AddServiceWebEndpoint(new WebHttpBinding - { - MaxReceivedMessageSize = 5242880, - MaxBufferSize = 65536 - }, "api", behavior => - { - behavior.HelpEnabled = true; - behavior.AutomaticFormatSelectionEnabled = true; - }); - }); - } -} diff --git a/WebHttp/WebHttp.csproj b/WebHttp/WebHttp.csproj deleted file mode 100644 index c65dae4..0000000 --- a/WebHttp/WebHttp.csproj +++ /dev/null @@ -1,21 +0,0 @@ - - - - Exe - net7.0 - preview - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/spacebattle.sln b/spacebattle.sln index 5005d34..6f04802 100644 --- a/spacebattle.sln +++ b/spacebattle.sln @@ -9,8 +9,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SpaceBattle.Lib.Tests", "Sp EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{121F26CD-4C34-4047-8072-E2F5C89F1A87}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebHttp", "WebHttp\WebHttp.csproj", "{4794D930-2823-4D5C-9847-5DFD7C19CDDE}" -EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU From dbdaa66e220feb4dd066e4e291e7c0c76363ae7d Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 18:01:32 +0600 Subject: [PATCH 02/13] feat: LAB6_2 Server start and stop --- SpaceBattle.App/App.cs | 18 +++++ SpaceBattle.Lib.Tests/StartServerTest.cs | 28 ++++++++ SpaceBattle.Lib.Tests/StopServerTest.cs | 84 ++++++++++++++++++++++++ SpaceBattle.Lib/InitCommands.cs | 51 ++++++++++++++ 4 files changed, 181 insertions(+) create mode 100644 SpaceBattle.App/App.cs create mode 100644 SpaceBattle.Lib.Tests/StartServerTest.cs create mode 100644 SpaceBattle.Lib.Tests/StopServerTest.cs create mode 100644 SpaceBattle.Lib/InitCommands.cs diff --git a/SpaceBattle.App/App.cs b/SpaceBattle.App/App.cs new file mode 100644 index 0000000..255a2a7 --- /dev/null +++ b/SpaceBattle.App/App.cs @@ -0,0 +1,18 @@ +using Hwdtech; +using SpaceBattle.Lib; + +public class App +{ + public static void Main(int[] args) + { + var NumberOfTreads = args[0]; + new InitCommand().Execute(); + Console.WriteLine("Запуск сервера\nСоздание и регистрация потоков..."); + IoC.Resolve("Game.Commands.StartServerCommand", NumberOfTreads).Execute(); + Console.WriteLine("Потоки запущены\nДля завершения работы сервера нажмите любую клавишу"); + Console.ReadKey(); + Console.WriteLine("Завершение работы сервера. Закрытие потоков..."); + IoC.Resolve("Game.Commands.StopServerCommand"); + Console.WriteLine("Все потоки закрыты. Завершение работы программы"); + } +} diff --git a/SpaceBattle.Lib.Tests/StartServerTest.cs b/SpaceBattle.Lib.Tests/StartServerTest.cs new file mode 100644 index 0000000..cd7806e --- /dev/null +++ b/SpaceBattle.Lib.Tests/StartServerTest.cs @@ -0,0 +1,28 @@ +using Hwdtech; +using Hwdtech.Ioc; +using Moq; + +namespace SpaceBattle.Lib.Test; + +public class StartServerTest +{ + public StartServerTest() + { + new InitScopeBasedIoCImplementationCommand().Execute(); + IoC.Resolve("Scopes.Current.Set", IoC.Resolve("Scopes.New", IoC.Resolve("Scopes.Root"))).Execute(); + var a = new InitCommand(); + a.Execute(); + } + [Fact] + public void Start_Server_Test() + { + var startCommand = new Mock(); + startCommand.Setup(cmd => cmd.Execute()).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Commands.CreateAndStartThread", (object[] args) => + { + return startCommand.Object; + }).Execute(); + IoC.Resolve("Game.Commands.StartServerCommand", 5).Execute(); + startCommand.Verify(cmd => cmd.Execute(), Times.Exactly(5)); + } +} \ No newline at end of file diff --git a/SpaceBattle.Lib.Tests/StopServerTest.cs b/SpaceBattle.Lib.Tests/StopServerTest.cs new file mode 100644 index 0000000..0bc07b3 --- /dev/null +++ b/SpaceBattle.Lib.Tests/StopServerTest.cs @@ -0,0 +1,84 @@ +using Hwdtech; +using Hwdtech.Ioc; +using Moq; + +namespace SpaceBattle.Lib.Test; + +public class StopServerTest +{ + public StopServerTest() + { + new InitScopeBasedIoCImplementationCommand().Execute(); + IoC.Resolve("Scopes.Current.Set", IoC.Resolve("Scopes.New", IoC.Resolve("Scopes.Root"))).Execute(); + + var logfilepath = Path.GetTempFileName(); + IoC.Resolve("IoC.Register", "GetLogFilePath", (object[] args) => + { + return logfilepath; + }).Execute(); + var a = new InitCommand(); + a.Execute(); + } + + public class SendCommandMock : Hwdtech.ICommand + { + private readonly Hwdtech.ICommand _command; + private readonly Hwdtech.ICommand _stopCommand; + + public SendCommandMock(Hwdtech.ICommand command, Hwdtech.ICommand stopCommand) + { + _command = command; + _stopCommand = stopCommand; + } + + public void Execute() + { + _command.Execute(); + _stopCommand.Execute(); + } + } + + [Fact] + public void StopServer_Test() + { + var threadList = new List { 1, 2, 3 }; + var barrier = new Barrier(4); + var stopCommand = new Mock(); + stopCommand.Setup(x => x.Execute()).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Commands.GetThreadIDs", (object[] args) => { return threadList; }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.StopServerBarrierRemove", (object[] args) => + { + return () => { barrier.RemoveParticipant(); }; + }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.StopServerBarrierWait", (object[] args) => + { + return new ActionCommand(() => { barrier.SignalAndWait(); }); + }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.SoftStopThread", (object[] args) => + { + return new ActionCommand((Action)args[1]); + }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.SendCommand", (object[] args) => + { + return new SendCommandMock((Hwdtech.ICommand)args[1], stopCommand.Object); + }).Execute(); + + IoC.Resolve("Game.Commands.StopServerCommand").Execute(); + + Assert.Equal(1, barrier.CurrentPhaseNumber); + stopCommand.Verify(cmd => cmd.Execute(), Times.Exactly(3)); + } + + [Fact] + public void StopServer_TestwithExeption() + { + IoC.Resolve("Game.Commands.ExeptionHandler", new ActionCommand(() => { }), new Exception()).Execute(); + + var testString = "Error occurred in command: SpaceBattle.Lib.ActionCommand\nException: System.Exception: Exception of type 'System.Exception' was thrown.\n"; + Assert.Equal(File.ReadAllText(IoC.Resolve("GetLogFilePath")), testString); + } +} diff --git a/SpaceBattle.Lib/InitCommands.cs b/SpaceBattle.Lib/InitCommands.cs new file mode 100644 index 0000000..8533971 --- /dev/null +++ b/SpaceBattle.Lib/InitCommands.cs @@ -0,0 +1,51 @@ +namespace SpaceBattle.Lib; +using System.Linq; +using Hwdtech; + +public class InitCommand : Hwdtech.ICommand +{ + public void Execute() + { + IoC.Resolve("IoC.Register", "Game.Commands.StartServerCommand", (object[] args) => + { + var NumberOfThreads = (int)args[0]; + + return new ActionCommand(() => + { + Enumerable.Range(0, NumberOfThreads).ToList().ForEach(i => + { + IoC.Resolve("Game.Commands.CreateAndStartThread").Execute(); + }); + }); + }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.ExeptionHandler", (object[] args) => + { + var errorFile = IoC.Resolve("GetLogFilePath"); + return new ActionCommand(() => + { + using (var sw = File.AppendText(errorFile)) + { + sw.WriteLine($"Error occurred in command: {args[0]}"); + sw.WriteLine($"Exception: {args[1]}"); + } + }); + }).Execute(); + + IoC.Resolve("IoC.Register", "Game.Commands.StopServerCommand", (object[] args) => + { + var ThreadList = IoC.Resolve>("Game.Commands.GetThreadIDs"); + return new ActionCommand(() => + { + ThreadList.ForEach(thread_id => + { + IoC.Resolve("Game.Commands.SendCommand", thread_id, + IoC.Resolve("Game.Commands.SoftStopThread", thread_id, + IoC.Resolve("Game.Commands.StopServerBarrierRemove"))).Execute(); + }); + + IoC.Resolve("Game.Commands.StopServerBarrierWait").Execute(); + }); + }).Execute(); + } +} From 80cbe0625d1b3e422dd462c914214e7feee1b887 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 19:29:30 +0600 Subject: [PATCH 03/13] fix: after 500 years of shuffling dependencies --- SpaceBattle.Lib.Tests/StartServerTest.cs | 4 ++-- SpaceBattle.Lib.Tests/StopServerTest.cs | 28 ++++++------------------ SpaceBattle.Lib/InitCommands.cs | 10 ++++----- 3 files changed, 14 insertions(+), 28 deletions(-) diff --git a/SpaceBattle.Lib.Tests/StartServerTest.cs b/SpaceBattle.Lib.Tests/StartServerTest.cs index cd7806e..33a0936 100644 --- a/SpaceBattle.Lib.Tests/StartServerTest.cs +++ b/SpaceBattle.Lib.Tests/StartServerTest.cs @@ -16,7 +16,7 @@ public StartServerTest() [Fact] public void Start_Server_Test() { - var startCommand = new Mock(); + var startCommand = new Mock(); startCommand.Setup(cmd => cmd.Execute()).Verifiable(); IoC.Resolve("IoC.Register", "Game.Commands.CreateAndStartThread", (object[] args) => { @@ -25,4 +25,4 @@ public void Start_Server_Test() IoC.Resolve("Game.Commands.StartServerCommand", 5).Execute(); startCommand.Verify(cmd => cmd.Execute(), Times.Exactly(5)); } -} \ No newline at end of file +} diff --git a/SpaceBattle.Lib.Tests/StopServerTest.cs b/SpaceBattle.Lib.Tests/StopServerTest.cs index 0bc07b3..42a85e2 100644 --- a/SpaceBattle.Lib.Tests/StopServerTest.cs +++ b/SpaceBattle.Lib.Tests/StopServerTest.cs @@ -20,30 +20,13 @@ public StopServerTest() a.Execute(); } - public class SendCommandMock : Hwdtech.ICommand - { - private readonly Hwdtech.ICommand _command; - private readonly Hwdtech.ICommand _stopCommand; - - public SendCommandMock(Hwdtech.ICommand command, Hwdtech.ICommand stopCommand) - { - _command = command; - _stopCommand = stopCommand; - } - - public void Execute() - { - _command.Execute(); - _stopCommand.Execute(); - } - } - [Fact] + public void StopServer_Test() { var threadList = new List { 1, 2, 3 }; var barrier = new Barrier(4); - var stopCommand = new Mock(); + var stopCommand = new Mock(); stopCommand.Setup(x => x.Execute()).Verifiable(); IoC.Resolve("IoC.Register", "Game.Commands.GetThreadIDs", (object[] args) => { return threadList; }).Execute(); @@ -61,10 +44,13 @@ public void StopServer_Test() { return new ActionCommand((Action)args[1]); }).Execute(); - IoC.Resolve("IoC.Register", "Game.Commands.SendCommand", (object[] args) => { - return new SendCommandMock((Hwdtech.ICommand)args[1], stopCommand.Object); + return new ActionCommand(() => + { + ((ICommand)args[1]).Execute(); + stopCommand.Object.Execute(); + }); }).Execute(); IoC.Resolve("Game.Commands.StopServerCommand").Execute(); diff --git a/SpaceBattle.Lib/InitCommands.cs b/SpaceBattle.Lib/InitCommands.cs index 8533971..96e978e 100644 --- a/SpaceBattle.Lib/InitCommands.cs +++ b/SpaceBattle.Lib/InitCommands.cs @@ -2,7 +2,7 @@ namespace SpaceBattle.Lib; using System.Linq; using Hwdtech; -public class InitCommand : Hwdtech.ICommand +public class InitCommand : ICommand { public void Execute() { @@ -14,7 +14,7 @@ public void Execute() { Enumerable.Range(0, NumberOfThreads).ToList().ForEach(i => { - IoC.Resolve("Game.Commands.CreateAndStartThread").Execute(); + IoC.Resolve("Game.Commands.CreateAndStartThread").Execute(); }); }); }).Execute(); @@ -39,12 +39,12 @@ public void Execute() { ThreadList.ForEach(thread_id => { - IoC.Resolve("Game.Commands.SendCommand", thread_id, - IoC.Resolve("Game.Commands.SoftStopThread", thread_id, + IoC.Resolve("Game.Commands.SendCommand", thread_id, + IoC.Resolve("Game.Commands.SoftStopThread", thread_id, IoC.Resolve("Game.Commands.StopServerBarrierRemove"))).Execute(); }); - IoC.Resolve("Game.Commands.StopServerBarrierWait").Execute(); + IoC.Resolve("Game.Commands.StopServerBarrierWait").Execute(); }); }).Execute(); } From b2a067a7046720b329cb72bc337573fa762f2f83 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 20:07:30 +0600 Subject: [PATCH 04/13] feat: LAB7_2 Message processing --- SpaceBattle.Lib.Tests/MessageTest.cs | 100 ++++++++++++++++++++++++++ SpaceBattle.Lib/IMessage.cs | 24 +++++++ SpaceBattle.Lib/MessageInterpreter.cs | 20 ++++++ 3 files changed, 144 insertions(+) create mode 100644 SpaceBattle.Lib.Tests/MessageTest.cs create mode 100644 SpaceBattle.Lib/IMessage.cs create mode 100644 SpaceBattle.Lib/MessageInterpreter.cs diff --git a/SpaceBattle.Lib.Tests/MessageTest.cs b/SpaceBattle.Lib.Tests/MessageTest.cs new file mode 100644 index 0000000..b8f9bcd --- /dev/null +++ b/SpaceBattle.Lib.Tests/MessageTest.cs @@ -0,0 +1,100 @@ +using Hwdtech; +using Hwdtech.Ioc; +using Moq; + +namespace SpaceBattle.Lib.Test; + +public class MessageTests +{ + public MessageTests() + { + new InitScopeBasedIoCImplementationCommand().Execute(); + + IoC.Resolve("Scopes.Current.Set", IoC.Resolve("Scopes.New", IoC.Resolve("Scopes.Root"))).Execute(); + } + [Fact] + public void QueuePushCommandPush() + { + var mockCommand = new Mock(); + var mockMessage = new Mock(); + mockCommand.Setup(a => a.Execute()).Verifiable(); + mockMessage.SetupGet(m => m.GameID).Returns("GameABC").Verifiable(); + + IoC.Resolve("IoC.Register", "Game.Queue.Push", (object[] args) => args[1]).Execute(); + IoC.Resolve("IoC.Register", "Game.CreateCommand", (object[] args) => mockCommand.Object).Execute(); + + var command = new InterpreterCommand(mockMessage.Object); + command.Execute(); + + mockCommand.Verify(x => x.Execute(), Times.Once); + } + [Fact] + public void Queue_CantReadId() + { + var mockCommand = new Mock(); + var mockMessage = new Mock(); + mockCommand.Setup(a => a.Execute()).Verifiable(); + mockMessage.SetupGet(m => m.GameID).Throws(new Exception()).Verifiable(); + + IoC.Resolve("IoC.Register", "Game.Queue.Push", (object[] args) => args[1]).Execute(); + IoC.Resolve("IoC.Register", "Game.CreateCommand", (object[] args) => mockCommand.Object).Execute(); + + var command = new InterpreterCommand(mockMessage.Object); + + Assert.Throws(command.Execute); + } + [Fact] + public void GameCreateCommand() + { + var mockCommand = new Mock(); + var mockMessage = new Mock(); + mockMessage.SetupGet(m => m.GameID).Returns("GameABC").Verifiable(); + mockCommand.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.CreateCommand", (object[] args) => + { + mockCommand.Object.Execute(); + return new ActionCommand(() => { }); + }).Execute(); + + var command = new InterpreterCommand(mockMessage.Object); + + Assert.Throws(command.Execute); + } + [Fact] + public void QueuePushError() + { + var mockCommand = new Mock(); + var mockMessage = new Mock(); + mockMessage.SetupGet(m => m.GameID).Returns("GameXYZ").Verifiable(); + mockCommand.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.CreateCommand", (object[] args) => new ActionCommand(() => { })).Execute(); + + IoC.Resolve("IoC.Register", "Game.Queue.Push", (object[] args) => + { + mockCommand.Object.Execute(); + return new ActionCommand(() => { }); + }).Execute(); + + var interpreterCommand = new InterpreterCommand(mockMessage.Object); + + Assert.Throws(interpreterCommand.Execute); + } + [Fact] + public void QueuePushCreatesBrokenCommand() + { + var mockCommand = new Mock(); + var mockMessage = new Mock(); + mockMessage.SetupGet(m => m.GameID).Returns("GameXYZ").Verifiable(); + mockCommand.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.CreateCommand", (object[] args) => new ActionCommand(() => { })).Execute(); + + IoC.Resolve("IoC.Register", "Game.Queue.Push", (object[] args) => + { + return mockCommand.Object; + }).Execute(); + + var interpreterCommand = new InterpreterCommand(mockMessage.Object); + + Assert.Throws(interpreterCommand.Execute); + } +} diff --git a/SpaceBattle.Lib/IMessage.cs b/SpaceBattle.Lib/IMessage.cs new file mode 100644 index 0000000..ae21b7d --- /dev/null +++ b/SpaceBattle.Lib/IMessage.cs @@ -0,0 +1,24 @@ +namespace SpaceBattle.Lib; + +public interface IMessage +{ + public string OrderType + { + get; + } + + public string GameID + { + get; + } + + public string GameItemID + { + get; + } + + public IDictionary Properties + { + get; + } +} diff --git a/SpaceBattle.Lib/MessageInterpreter.cs b/SpaceBattle.Lib/MessageInterpreter.cs new file mode 100644 index 0000000..bff1926 --- /dev/null +++ b/SpaceBattle.Lib/MessageInterpreter.cs @@ -0,0 +1,20 @@ +using Hwdtech; + +namespace SpaceBattle.Lib +{ + public class InterpreterCommand : ICommand + { + private readonly IMessage _customMessage; + + public InterpreterCommand(IMessage message) + { + _customMessage = message; + } + public void Execute() + { + var id = _customMessage.GameID; + var cmd = IoC.Resolve("Game.CreateCommand", _customMessage); + IoC.Resolve("Game.Queue.Push", id, cmd).Execute(); + } + } +} From 431b037651f1f415bd4c651b0bb504380925c1a4 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:23:51 +0600 Subject: [PATCH 05/13] feat: LAB8_2 Create Game Class Strategy --- SpaceBattle.Lib.Tests/InitializeGameTest.cs | 548 ++++++++++++++++++++ SpaceBattle.Lib/CreateGameScopeStrategy.cs | 34 ++ SpaceBattle.Lib/CreateGameStrategy.cs | 28 + SpaceBattle.Lib/DeleteGameCommand.cs | 21 + SpaceBattle.Lib/DeleteObjectCommand.cs | 17 + SpaceBattle.Lib/EmptyCommand.cs | 6 + SpaceBattle.Lib/GetObjectStrategy.cs | 11 + SpaceBattle.Lib/IGameStrategy.cs | 6 + SpaceBattle.Lib/ISimpleStrategy.cs | 5 + SpaceBattle.Lib/QueuePopStrategy.cs | 12 + SpaceBattle.Lib/QueuePushCommand.cs | 17 + 11 files changed, 705 insertions(+) create mode 100644 SpaceBattle.Lib.Tests/InitializeGameTest.cs create mode 100644 SpaceBattle.Lib/CreateGameScopeStrategy.cs create mode 100644 SpaceBattle.Lib/CreateGameStrategy.cs create mode 100644 SpaceBattle.Lib/DeleteGameCommand.cs create mode 100644 SpaceBattle.Lib/DeleteObjectCommand.cs create mode 100644 SpaceBattle.Lib/EmptyCommand.cs create mode 100644 SpaceBattle.Lib/GetObjectStrategy.cs create mode 100644 SpaceBattle.Lib/IGameStrategy.cs create mode 100644 SpaceBattle.Lib/ISimpleStrategy.cs create mode 100644 SpaceBattle.Lib/QueuePopStrategy.cs create mode 100644 SpaceBattle.Lib/QueuePushCommand.cs diff --git a/SpaceBattle.Lib.Tests/InitializeGameTest.cs b/SpaceBattle.Lib.Tests/InitializeGameTest.cs new file mode 100644 index 0000000..ddbfa05 --- /dev/null +++ b/SpaceBattle.Lib.Tests/InitializeGameTest.cs @@ -0,0 +1,548 @@ +using Hwdtech; +using Hwdtech.Ioc; +using Moq; + +namespace SpaceBattle.Lib.Test; + +public class InitializeGameTests +{ + public InitializeGameTests() + { + new InitScopeBasedIoCImplementationCommand().Execute(); + IoC.Resolve("Scopes.Current.Set", IoC.Resolve("Scopes.New", IoC.Resolve("Scopes.Root"))).Execute(); + } + [Fact] + public void GetObjectStrategy_Test_Success() + { + var objectDict = new Dictionary(); + var obj = new Mock(); + objectDict.Add(1, obj.Object); + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => objectDict).Execute(); + var strategy = new GetObjectStrategy(); + var result = strategy.Run(1); + Assert.Equal(obj.Object, result); + } + [Fact] + public void GetObjectStrategy_Test_DisabbilityToGetIUObjectListCauseException() + { + var objectDict = new Dictionary(); + var obj = new Mock(); + objectDict.Add(1, obj.Object); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => + { + badcmd.Object.Execute(); + return objectDict; + }).Execute(); + var strategy = new GetObjectStrategy(); + Assert.Throws(() => strategy.Run(1)); + } + [Fact] + public void GetObjectStrategy_Test_NoObjectIdCauseException() + { + var objectDict = new Dictionary(); + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => objectDict).Execute(); + var strategy = new GetObjectStrategy(); + Assert.Throws(() => strategy.Run(1)); + } + [Fact] + public void DeleteObjectStrategy_Test_Success() + { + var objectDict = new Dictionary(); + var obj = new Mock(); + objectDict.Add(1, obj.Object); + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => objectDict).Execute(); + new DeleteObjectCommand(1).Execute(); + Assert.Empty(objectDict); + } + [Fact] + public void DeleteObjectStrategy_Test_DisabbilityToGetIUObjectListCauseException() + { + var objectDict = new Dictionary(); + var obj = new Mock(); + objectDict.Add(1, obj.Object); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => + { + badcmd.Object.Execute(); + return objectDict; + }).Execute(); + Assert.Throws(() => { new DeleteObjectCommand(1).Execute(); }); + } + [Fact] + public void QueuePopStrategy_Test_Success() + { + var queue = new Mock(); + var cmd = new Mock(); + queue.Setup(x => x.Take()).Returns(cmd.Object); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => queue.Object).Execute(); + var strategy = new QueuePopStrategy(); + Assert.Equal(cmd.Object, strategy.Run()); + } + [Fact] + public void QueuePopStrategy_Test_DisabilityToGetQueueCauseException() + { + var queue = new Mock(); + var cmd = new Mock(); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + queue.Setup(x => x.Take()).Returns(cmd.Object); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => + { + badcmd.Object.Execute(); + return queue.Object; + }).Execute(); + var strategy = new QueuePopStrategy(); + Assert.Throws(() => strategy.Run()); + } + [Fact] + public void QueuePopStrategy_Test_DisabilityToTakeCommandCauseException() + { + var queue = new Mock(); + queue.Setup(x => x.Take()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => + { + return queue.Object; + }).Execute(); + var strategy = new QueuePopStrategy(); + Assert.Throws(() => strategy.Run()); + } + [Fact] + public void QueuePushStrategy_Test_Success() + { + var queue = new Mock(); + var cmd = new Mock(); + var realqueue = new Queue(); + queue.Setup(x => x.Add(It.IsAny())).Callback(cmd => { realqueue.Enqueue(cmd); }); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => queue.Object).Execute(); + var pushCommand = new QueuePushCommand(cmd.Object); + pushCommand.Execute(); + Assert.Equal(cmd.Object, realqueue.Peek()); + } + [Fact] + public void QueuePushStrategy_Test_DisabilityToGetQueueCauseException() + { + var queue = new Mock(); + var cmd = new Mock(); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + var realqueue = new Queue(); + queue.Setup(x => x.Add(It.IsAny())).Callback(cmd => { realqueue.Enqueue(cmd); }); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => + { + badcmd.Object.Execute(); + return queue.Object; + }).Execute(); + var pushCommand = new QueuePushCommand(cmd.Object); + + Assert.Throws(() => { pushCommand.Execute(); }); + } + [Fact] + public void QueuePushStrategy_Test_DisabilityToAddCommandCauseException() + { + var queue = new Mock(); + var cmd = new Mock(); + queue.Setup(x => x.Add(It.IsAny())).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => queue.Object).Execute(); + var pushCommand = new QueuePushCommand(cmd.Object); + + Assert.Throws(() => { pushCommand.Execute(); }); + } + [Fact] + public void DeleteGameCommand_Test_Success() + { + var gameList = new Mock>(); + var injectCommand = new Mock(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + gameList.SetupGet(x => x[It.IsAny()]).Returns(injectCommand.Object); + injectCommand.Setup(x => x.Inject(It.IsAny())).Verifiable(); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => scopeList.Object).Execute(); + + var command = new DeleteGameCommand("1"); + command.Execute(); + + scopeList.Verify(x => x.Remove(It.IsAny()), Times.Once()); + injectCommand.Verify(x => x.Inject(It.IsAny()), Times.Once()); + } + [Fact] + public void DeleteGameCommand_Test_DisabilityToGetGameListCauseException() + { + var gameList = new Mock>(); + var injectCommand = new Mock(); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => + { + badcmd.Object.Execute(); + return gameList.Object; + }).Execute(); + + gameList.SetupGet(x => x[It.IsAny()]).Returns(injectCommand.Object); + injectCommand.Setup(x => x.Inject(It.IsAny())).Verifiable(); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => scopeList.Object).Execute(); + + var command = new DeleteGameCommand("1"); + + Assert.Throws(() => { command.Execute(); }); + } + [Fact] + public void DeleteGameCommand_Test_DisabilityToGetScopeListCauseException() + { + var gameList = new Mock>(); + var injectCommand = new Mock(); + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + gameList.SetupGet(x => x[It.IsAny()]).Returns(injectCommand.Object); + injectCommand.Setup(x => x.Inject(It.IsAny())).Verifiable(); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => + { + badcmd.Object.Execute(); + return scopeList.Object; + }).Execute(); + + var command = new DeleteGameCommand("1"); + + Assert.Throws(() => { command.Execute(); }); + } + [Fact] + public void DeleteGameCommand_Test_DisabilityToGetObjectFromGameListCauseException() + { + var gameList = new Mock>(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + gameList.SetupGet(x => x[It.IsAny()]).Throws(new Exception()); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => scopeList.Object).Execute(); + + var command = new DeleteGameCommand("1"); + + Assert.Throws(() => { command.Execute(); }); + } + [Fact] + public void DeleteGameCommand_Test_DisabilityToInjectCommandCauseException() + { + var gameList = new Mock>(); + var injectCommand = new Mock(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + gameList.SetupGet(x => x[It.IsAny()]).Returns(injectCommand.Object); + injectCommand.Setup(x => x.Inject(It.IsAny())).Throws(new Exception()); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => scopeList.Object).Execute(); + + var command = new DeleteGameCommand("1"); + + Assert.Throws(() => { command.Execute(); }); + } + [Fact] + public void DeleteGameCommand_Test_DisabilityToRemoveScopedCauseException() + { + var gameList = new Mock>(); + var injectCommand = new Mock(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + gameList.SetupGet(x => x[It.IsAny()]).Returns(injectCommand.Object); + injectCommand.Setup(x => x.Inject(It.IsAny())).Verifiable(); + var scopeList = new Mock>(); + scopeList.Setup(x => x.Remove(It.IsAny())).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => scopeList.Object).Execute(); + + var command = new DeleteGameCommand("1"); + + Assert.Throws(() => { command.Execute(); }); + } + [Fact] + public void CreateGameStrategy_Test_Success() + { + var testCommand = new Mock(); + testCommand.Setup(x => x.Execute()).Verifiable(); + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => + { + testCommand.Object.Execute(); + return (object)1; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => + { + testCommand.Object.Execute(); + return (object)1; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => + { + testCommand.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => + { + testCommand.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => + { + testCommand.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => + { + testCommand.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => + { + testCommand.Object.Execute(); + return gameList.Object; + }).Execute(); + + var strategy = new CreateGameStrategy(); + strategy.Run("1", 1, (double)1); + + testCommand.Verify(x => x.Execute(), Times.Exactly(7)); + gameList.Verify(x => x.Add(It.IsAny(), It.IsAny()), Times.Once()); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToGetGameListCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => + { + badcmd.Object.Execute(); + return gameList.Object; + }).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToAddGameToListCauseExeption() + { + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeRepeatCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => + { + badcmd.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeInjectCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => + { + badcmd.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeMacroCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => + { + badcmd.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeGameCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => + { + badcmd.Object.Execute(); + return gameCommand.Object; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeNewQueueCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => + { + badcmd.Object.Execute(); + return (object)1; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameStrategy_Test_DisabilityToMakeNewScopeCommandCauseExeption() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameCommand = new Mock(); + var gameList = new Mock>(); + gameList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.New", (object[] args) => + { + badcmd.Object.Execute(); + return (object)1; + }).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.New", (object[] args) => (object)1).Execute(); + IoC.Resolve("IoC.Register", "Game.Command", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Macro", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.Command.Inject", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Command.Command.Repeat", (object[] args) => gameCommand.Object).Execute(); + IoC.Resolve("IoC.Register", "Game.GetGamesList", (object[] args) => gameList.Object).Execute(); + + var strategy = new CreateGameStrategy(); + + Assert.Throws(() => strategy.Run("1", 1, (double)1)); + } + [Fact] + public void CreateGameScopeStrategy_Test_Success() + { + var gameScopeList = new Mock>(); + gameScopeList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => gameScopeList.Object).Execute(); + + var strategy = new NewGameScopeStrategy(); + strategy.Run("1", IoC.Resolve("Scopes.Current"), (object)1, (double)1); + + gameScopeList.Verify(x => x.Add(It.IsAny(), It.IsAny()), Times.Once()); + } + [Fact] + public void CreateGameScopeStrategy_Test_DisabilityToGetScopeListCauseExcepyion() + { + var badcmd = new Mock(); + badcmd.Setup(x => x.Execute()).Throws(new Exception()); + + var gameScopeList = new Mock>(); + gameScopeList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Verifiable(); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => + { + badcmd.Object.Execute(); + return gameScopeList.Object; + }).Execute(); + + var strategy = new NewGameScopeStrategy(); + + Assert.Throws(() => strategy.Run("1", IoC.Resolve("Scopes.Current"), (object)1, (double)1)); + } + [Fact] + public void CreateGameScopeStrategy_Test_DisabilityToRegisterScopeCauseException() + { + var gameScopeList = new Mock>(); + gameScopeList.Setup(x => x.Add(It.IsAny(), It.IsAny())).Throws(new Exception()); + IoC.Resolve("IoC.Register", "Game.Scope.List", (object[] args) => gameScopeList.Object).Execute(); + + var strategy = new NewGameScopeStrategy(); + + Assert.Throws(() => strategy.Run("1", IoC.Resolve("Scopes.Current"), (object)1, (double)1)); + } +} diff --git a/SpaceBattle.Lib/CreateGameScopeStrategy.cs b/SpaceBattle.Lib/CreateGameScopeStrategy.cs new file mode 100644 index 0000000..b9942db --- /dev/null +++ b/SpaceBattle.Lib/CreateGameScopeStrategy.cs @@ -0,0 +1,34 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class NewGameScopeStrategy : IGameStrategy +{ + public object Run(params object[] args) + { + var gameId = (string)args[0]; + var parentScope = (object)args[1]; + var gameQueue = (object)args[2]; + var quant = (double)args[3]; + + var gameScope = IoC.Resolve("Scopes.New", parentScope); + + var gameScopeList = IoC.Resolve>("Game.Scope.List"); + gameScopeList.Add(gameId, gameScope); + + var currentScope = IoC.Resolve("Scopes.Current"); + + IoC.Resolve("Scopes.Current.Set", gameScope).Execute(); + IoC.Resolve("IoC.Register", "Game.Quant", (object[] args) => (object)quant).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue", (object[] args) => gameQueue).Execute(); + var objDict = new Dictionary(); + IoC.Resolve("IoC.Register", "Game.IUObject.List", (object[] args) => objDict).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.Pop", (object[] args) => { return new QueuePopStrategy().Run(); }).Execute(); + IoC.Resolve("IoC.Register", "Game.Queue.Push", (object[] args) => { return new QueuePushCommand((ICommand)args[0]); }).Execute(); + IoC.Resolve("IoC.Register", "Game.IUObject.Delete", (object[] args) => { return new DeleteObjectCommand((int)args[0]); }).Execute(); + IoC.Resolve("IoC.Register", "Game.IUObject.Get", (object[] args) => { return new GetObjectStrategy().Run(args); }).Execute(); + IoC.Resolve("Scopes.Current.Set", currentScope).Execute(); + + return gameScope; + } +} diff --git a/SpaceBattle.Lib/CreateGameStrategy.cs b/SpaceBattle.Lib/CreateGameStrategy.cs new file mode 100644 index 0000000..1659b2d --- /dev/null +++ b/SpaceBattle.Lib/CreateGameStrategy.cs @@ -0,0 +1,28 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class CreateGameStrategy : IGameStrategy +{ + public object Run(params object[] args) + { + var gameId = (string)args[0]; + var parentScope = (object)args[1]; + var quant = (double)args[2]; + + var gameQueue = IoC.Resolve("Game.Queue.New"); + var gameScope = IoC.Resolve("Game.Scope.New", gameId, parentScope, gameQueue, quant); + var gameCommand = IoC.Resolve("Game.Command", gameQueue, gameScope); + + var commandsList = new List { gameCommand }; + var macroCommand = IoC.Resolve("Game.Command.Macro", commandsList); + var injectCommand = IoC.Resolve("Game.Command.Inject", macroCommand); + var repeatCommand = IoC.Resolve("Command.Command.Repeat", injectCommand); + commandsList.Add(repeatCommand); + + var gameList = IoC.Resolve>("Game.GetGamesList"); + gameList.Add(gameId, injectCommand); + + return injectCommand; + } +} diff --git a/SpaceBattle.Lib/DeleteGameCommand.cs b/SpaceBattle.Lib/DeleteGameCommand.cs new file mode 100644 index 0000000..63632c1 --- /dev/null +++ b/SpaceBattle.Lib/DeleteGameCommand.cs @@ -0,0 +1,21 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class DeleteGameCommand : ICommand +{ + private readonly string gameId; + + public DeleteGameCommand(string gameId) + { + this.gameId = gameId; + } + public void Execute() + { + var gameList = IoC.Resolve>("Game.GetGamesList"); + gameList[gameId].Inject(new EmptyCommand()); + + var gameScopeList = IoC.Resolve>("Game.Scope.List"); + gameScopeList.Remove(gameId); + } +} diff --git a/SpaceBattle.Lib/DeleteObjectCommand.cs b/SpaceBattle.Lib/DeleteObjectCommand.cs new file mode 100644 index 0000000..cd37410 --- /dev/null +++ b/SpaceBattle.Lib/DeleteObjectCommand.cs @@ -0,0 +1,17 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class DeleteObjectCommand : ICommand +{ + private readonly int objectId; + + public DeleteObjectCommand(int objectId) + { + this.objectId = objectId; + } + public void Execute() + { + IoC.Resolve>("Game.IUObject.List").Remove(objectId); + } +} diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs new file mode 100644 index 0000000..b878f3f --- /dev/null +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -0,0 +1,6 @@ +namespace SpaceBattle.Lib; + +public class EmptyCommand: ICommand +{ + public void Execute() { } +} \ No newline at end of file diff --git a/SpaceBattle.Lib/GetObjectStrategy.cs b/SpaceBattle.Lib/GetObjectStrategy.cs new file mode 100644 index 0000000..3f57391 --- /dev/null +++ b/SpaceBattle.Lib/GetObjectStrategy.cs @@ -0,0 +1,11 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class GetObjectStrategy : IGameStrategy +{ + public object Run(params object[] args) + { + return IoC.Resolve>("Game.IUObject.List")[(int)args[0]]; + } +} diff --git a/SpaceBattle.Lib/IGameStrategy.cs b/SpaceBattle.Lib/IGameStrategy.cs new file mode 100644 index 0000000..7ecb25b --- /dev/null +++ b/SpaceBattle.Lib/IGameStrategy.cs @@ -0,0 +1,6 @@ +namespace SpaceBattle.Lib; + +public interface IGameStrategy +{ + public object Run(params object[] args); +} diff --git a/SpaceBattle.Lib/ISimpleStrategy.cs b/SpaceBattle.Lib/ISimpleStrategy.cs new file mode 100644 index 0000000..712c034 --- /dev/null +++ b/SpaceBattle.Lib/ISimpleStrategy.cs @@ -0,0 +1,5 @@ +namespace SpaceBattle.Lib; +public interface ISimpleStrategy +{ + public object Run(); +} diff --git a/SpaceBattle.Lib/QueuePopStrategy.cs b/SpaceBattle.Lib/QueuePopStrategy.cs new file mode 100644 index 0000000..7e32885 --- /dev/null +++ b/SpaceBattle.Lib/QueuePopStrategy.cs @@ -0,0 +1,12 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class QueuePopStrategy : ISimpleStrategy +{ + public object Run() + { + var queue = IoC.Resolve("Game.Queue"); + return queue.Take(); + } +} diff --git a/SpaceBattle.Lib/QueuePushCommand.cs b/SpaceBattle.Lib/QueuePushCommand.cs new file mode 100644 index 0000000..875fa71 --- /dev/null +++ b/SpaceBattle.Lib/QueuePushCommand.cs @@ -0,0 +1,17 @@ +using Hwdtech; + +namespace SpaceBattle.Lib; + +public class QueuePushCommand : ICommand +{ + private readonly ICommand command; + public QueuePushCommand(ICommand command) + { + this.command = command; + } + public void Execute() + { + var queue = IoC.Resolve("Game.Queue"); + queue.Add(command); + } +} From 1e7c7a3616b52db0103081706bc4f0a96fb38ac5 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:26:52 +0600 Subject: [PATCH 06/13] format: whitespace at the end of the file --- SpaceBattle.Lib/EmptyCommand.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index b878f3f..4356d5a 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -3,4 +3,4 @@ namespace SpaceBattle.Lib; public class EmptyCommand: ICommand { public void Execute() { } -} \ No newline at end of file +} From 843a0f073d7a0c27caee78a4e92e640988e182ff Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:29:19 +0600 Subject: [PATCH 07/13] refactor: delete redundant variable and comment --- SpaceBattle.Lib/CheckCollision.cs | 3 --- 1 file changed, 3 deletions(-) diff --git a/SpaceBattle.Lib/CheckCollision.cs b/SpaceBattle.Lib/CheckCollision.cs index 164dbae..c39ff91 100644 --- a/SpaceBattle.Lib/CheckCollision.cs +++ b/SpaceBattle.Lib/CheckCollision.cs @@ -5,7 +5,6 @@ namespace SpaceBattle.Lib; public class CheckCollision : ICommand { private readonly IUObject obj1, obj2; - private bool collision = true; public CheckCollision(IUObject uobj1, IUObject uobj2) { @@ -22,8 +21,6 @@ public void Execute() var list = object1.Zip(object2, (a, b) => a - b).ToList(); - // list.ForEach(n => builddecisiontree = (IDictionary)builddecisiontree[n]); - foreach (var item in list) { if (builddecisiontree.TryGetValue(item, out var value)) From 59636d5bfd1291bf851479b00bb5f456be816f47 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:32:30 +0600 Subject: [PATCH 08/13] format: lllll --- SpaceBattle.Lib/EmptyCommand.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index 4356d5a..b878f3f 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -3,4 +3,4 @@ namespace SpaceBattle.Lib; public class EmptyCommand: ICommand { public void Execute() { } -} +} \ No newline at end of file From 63ef980e6aa7dd01833c8bf039b1266d8f8360a0 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:33:31 +0600 Subject: [PATCH 09/13] format: whitespace --- SpaceBattle.Lib/EmptyCommand.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index b878f3f..4356d5a 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -3,4 +3,4 @@ namespace SpaceBattle.Lib; public class EmptyCommand: ICommand { public void Execute() { } -} \ No newline at end of file +} From 9b5c36747a00d412dac27f84f808dafc558e2581 Mon Sep 17 00:00:00 2001 From: Kotov Sergey <124546798+BoneFuusen@users.noreply.github.com> Date: Tue, 17 Mar 2026 21:34:46 +0600 Subject: [PATCH 10/13] Update EmptyCommand.cs From 81da66836b2e68d0d2e56079d575bfcbb184f059 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:39:23 +0600 Subject: [PATCH 11/13] format: whitespace2 --- SpaceBattle.Lib/EmptyCommand.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index 4356d5a..cd609ae 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -4,3 +4,4 @@ public class EmptyCommand: ICommand { public void Execute() { } } + From 36449cd284e9a8543367d703d99652a1e047d10e Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Tue, 17 Mar 2026 21:41:07 +0600 Subject: [PATCH 12/13] format: whitespace the last --- SpaceBattle.Lib/EmptyCommand.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index cd609ae..4356d5a 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -4,4 +4,3 @@ public class EmptyCommand: ICommand { public void Execute() { } } - From 3bbab14e2130620ffaf4c45b741a77fae09b1530 Mon Sep 17 00:00:00 2001 From: BoneFuusen Date: Fri, 20 Mar 2026 16:37:53 +0600 Subject: [PATCH 13/13] format: whitespace --- SpaceBattle.Lib/EmptyCommand.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SpaceBattle.Lib/EmptyCommand.cs b/SpaceBattle.Lib/EmptyCommand.cs index 4356d5a..04ab82b 100644 --- a/SpaceBattle.Lib/EmptyCommand.cs +++ b/SpaceBattle.Lib/EmptyCommand.cs @@ -1,6 +1,6 @@ namespace SpaceBattle.Lib; -public class EmptyCommand: ICommand +public class EmptyCommand : ICommand { public void Execute() { } }