Introduce async methods in application services

izzat5233 · izzat5233 · commit 71a5f547fcd6 · 2024-03-27T01:43:37.000+02:00
diff --git a/RealTimeWeatherMonitoringApp/Application/Interfaces/IDataReceiver.cs b/RealTimeWeatherMonitoringApp/Application/Interfaces/IDataReceiver.cs
@@ -7,4 +7,6 @@ namespace RealTimeWeatherMonitoringApp.Application.Interfaces;
 public interface IDataReceiver<in TReceived>
 {
     void Receive(TReceived? data);
+
+    Task ReceiveAsync(TReceived? data);
 }
diff --git a/RealTimeWeatherMonitoringApp/Application/Interfaces/Service/IAutoParsingService.cs b/RealTimeWeatherMonitoringApp/Application/Interfaces/Service/IAutoParsingService.cs
@@ -19,4 +19,9 @@ public interface IAutoParsingService<TResult>
     /// <returns>A <see cref="ParsingResult{TResult}"/> object that encapsulates the result of the parsing operation,
     /// indicating success or failure, and containing the parsed <typeparamref name="TResult"/> if successful.</returns>
     ParsingResult<TResult> AutoParse(string input);
+
+    /// <summary>
+    /// Asynchronous version of <see cref="AutoParse"/>
+    /// </summary>
+    Task<ParsingResult<TResult>> AutoParseAsync(string input);
 }
diff --git a/RealTimeWeatherMonitoringApp/Application/Interfaces/Service/IDataProcessingService.cs b/RealTimeWeatherMonitoringApp/Application/Interfaces/Service/IDataProcessingService.cs
@@ -15,4 +15,9 @@ public interface IDataProcessingService<TData>
     /// <returns>A <see cref="ParsingResult{TData}"/> object that encapsulates the result of the parsing operation,
     /// indicating success or failure, and containing the parsed <see cref="TData"/> if successful.</returns>
     ParsingResult<TData> Process(string input);
+
+    /// <summary>
+    /// Asynchronous version of <see cref="Process"/>
+    /// </summary>
+    Task<ParsingResult<TData>> ProcessAsync(string input);
 }
diff --git a/RealTimeWeatherMonitoringApp/Application/Service/AutoParsingService.cs b/RealTimeWeatherMonitoringApp/Application/Service/AutoParsingService.cs
@@ -23,4 +23,7 @@ public ParsingResult<TResult> AutoParse(string input)
 
         return new ParsingResult<TResult>(false, $"No valid parsing strategy was found for input '{input}'");
     }
+
+    public async Task<ParsingResult<TResult>> AutoParseAsync(string input) =>
+        await Task.Run(() => AutoParse(input));
 }
diff --git a/RealTimeWeatherMonitoringApp/Application/Service/DataProcessingService.cs b/RealTimeWeatherMonitoringApp/Application/Service/DataProcessingService.cs
@@ -21,4 +21,12 @@ public ParsingResult<TData> Process(string input)
         if (result.Success) _receiver.Receive(result.Data);
         return result;
     }
+
+    public async Task<ParsingResult<TData>> ProcessAsync(string input)
+    {
+        var result = await _autoParsingService.AutoParseAsync(input);
+        if (result.Success)
+            await _receiver.ReceiveAsync(result.Data);
+        return result;
+    }
 }
diff --git a/RealTimeWeatherMonitoringApp/Application/Service/MonitoringService.cs b/RealTimeWeatherMonitoringApp/Application/Service/MonitoringService.cs
@@ -12,5 +12,7 @@ public class MonitoringService<TData> : IDataReceiver<TData>, IDataChangeNotifie
     public void Receive(TData? data) =>
         OnDataChange?.Invoke(this, new DataChangeEventArgs<TData>(data));
 
+    public async Task ReceiveAsync(TData? data) => await Task.Run(() => Receive(data));
+
     public event EventHandler<DataChangeEventArgs<TData>>? OnDataChange;
 }
diff --git a/RealTimeWeatherMonitoringApp/Presentation/Controller/UserController.cs b/RealTimeWeatherMonitoringApp/Presentation/Controller/UserController.cs
@@ -16,7 +16,7 @@ public UserController(
         _weatherDataProcessor = weatherDataProcessor;
     }
 
-    public void Start()
+    public async Task Start()
     {
         _botNotificationService.OnBotNotification += (_, args) =>
             Console.WriteLine($"\n{args.BotName}:  {args.Message}");
@@ -34,7 +34,7 @@ public void Start()
             var input = Console.ReadLine() ?? string.Empty;
             if (input.Equals("q", StringComparison.CurrentCultureIgnoreCase)) break;
 
-            var result = _weatherDataProcessor.Process(input);
+            var result = await _weatherDataProcessor.ProcessAsync(input);
             if (result.Fail) Console.WriteLine(result.Message);
         }
     }
diff --git a/RealTimeWeatherMonitoringApp/Presentation/Program.cs b/RealTimeWeatherMonitoringApp/Presentation/Program.cs
@@ -7,4 +7,4 @@
 
 // Start
 provider.GetRequiredService<ServerController>().Start();
-provider.GetRequiredService<UserController>().Start();
+await provider.GetRequiredService<UserController>().Start();
diff --git a/RealTimeWeatherMonitoringTest/Application/Service/AutoParsingServiceShould.cs b/RealTimeWeatherMonitoringTest/Application/Service/AutoParsingServiceShould.cs
@@ -17,7 +17,10 @@ public void AutoParse_NoParsingStrategyWorks_ReturnFailResult(
         AutoParsingService<TestData> autoParsingService)
     {
         foreach (var mock in strategyMocks)
+        {
             autoParsingService.AddStrategy(mock.Object);
+            mock.Setup(s => s.TryParse(input, out It.Ref<TestData?>.IsAny)).Returns(false);
+        }
 
         var result = autoParsingService.AutoParse(input);
 
@@ -26,6 +29,25 @@ public void AutoParse_NoParsingStrategyWorks_ReturnFailResult(
         result.Data.Should().BeNull();
     }
 
+    [Theory, AutoMoqData]
+    public async Task AutoParseAsync_NoParsingStrategyWorks_ReturnFailResult(
+        string input,
+        List<Mock<IParsingStrategy<TestData>>> strategyMocks,
+        AutoParsingService<TestData> autoParsingService)
+    {
+        foreach (var mock in strategyMocks)
+        {
+            autoParsingService.AddStrategy(mock.Object);
+            mock.Setup(s => s.TryParse(input, out It.Ref<TestData?>.IsAny)).Returns(false);
+        }
+
+        var result = await autoParsingService.AutoParseAsync(input);
+
+        result.Should().NotBeNull();
+        result.Success.Should().BeFalse();
+        result.Data.Should().BeNull();
+    }
+
     [Theory, AutoMoqData]
     public void AutoParse_AStrategyWorks_ReturnSuccessResult(
         string input,
@@ -43,23 +65,62 @@ public void AutoParse_AStrategyWorks_ReturnSuccessResult(
         result.Data.Should().BeSameAs(resultData);
     }
 
+    [Theory, AutoMoqData]
+    public async Task AutoParseAsync_AStrategyWorks_ReturnSuccessResult(
+        string input,
+        TestData? resultData,
+        Mock<IParsingStrategy<TestData>> strategyMock,
+        AutoParsingService<TestData> autoParsingService)
+    {
+        autoParsingService.AddStrategy(strategyMock.Object);
+        strategyMock.Setup(s => s.TryParse(input, out resultData)).Returns(true);
+
+        var result = await autoParsingService.AutoParseAsync(input);
+
+        result.Should().NotBeNull();
+        result.Success.Should().BeTrue();
+        result.Data.Should().BeSameAs(resultData);
+    }
+
     [Theory, AutoMoqData]
     public void AutoParse_MultipleStrategiesWork_UseFirstOne(
         string input,
+        TestData? firstResultData,
+        TestData? secondResultData,
         Mock<IParsingStrategy<TestData>> firstStrategyMock,
         Mock<IParsingStrategy<TestData>> secondStrategyMock,
         AutoParsingService<TestData> autoParsingService)
     {
         autoParsingService.AddStrategy(firstStrategyMock.Object);
         autoParsingService.AddStrategy(secondStrategyMock.Object);
 
-        TestData? dummy = null;
-        firstStrategyMock.Setup(s => s.TryParse(input, out dummy)).Returns(true);
-        secondStrategyMock.Setup(s => s.TryParse(input, out dummy)).Returns(true);
+        firstStrategyMock.Setup(s => s.TryParse(input, out firstResultData)).Returns(true);
+        secondStrategyMock.Setup(s => s.TryParse(input, out secondResultData)).Returns(true);
 
         autoParsingService.AutoParse(input);
 
-        firstStrategyMock.Verify(s => s.TryParse(input, out dummy), Times.Once);
-        secondStrategyMock.Verify(s => s.TryParse(input, out dummy), Times.Never);
+        firstStrategyMock.Verify(s => s.TryParse(input, out firstResultData), Times.Once);
+        secondStrategyMock.Verify(s => s.TryParse(input, out secondResultData), Times.Never);
+    }
+
+    [Theory, AutoMoqData]
+    public async Task AutoParseAsync_MultipleStrategiesWork_UseFirstOne(
+        string input,
+        TestData? firstResultData,
+        TestData? secondResultData,
+        Mock<IParsingStrategy<TestData>> firstStrategyMock,
+        Mock<IParsingStrategy<TestData>> secondStrategyMock,
+        AutoParsingService<TestData> autoParsingService)
+    {
+        autoParsingService.AddStrategy(firstStrategyMock.Object);
+        autoParsingService.AddStrategy(secondStrategyMock.Object);
+
+        firstStrategyMock.Setup(s => s.TryParse(input, out firstResultData)).Returns(true);
+        secondStrategyMock.Setup(s => s.TryParse(input, out secondResultData)).Returns(true);
+
+        await autoParsingService.AutoParseAsync(input);
+
+        firstStrategyMock.Verify(s => s.TryParse(input, out firstResultData), Times.Once);
+        secondStrategyMock.Verify(s => s.TryParse(input, out secondResultData), Times.Never);
     }
 }
diff --git a/RealTimeWeatherMonitoringTest/Application/Service/DataProcessingServiceShould.cs b/RealTimeWeatherMonitoringTest/Application/Service/DataProcessingServiceShould.cs
@@ -32,6 +32,25 @@ public void Process_SuccessfulParsing_SendDataToReceiver(
         result.Should().BeSameAs(parsingResult);
     }
 
+    [Theory, AutoMoqData]
+    public async Task ProcessAsync_SuccessfulAsyncParsing_SendDataToReceiverAsync(
+        string goodInput,
+        ParsingResult<TestData> parsingResult,
+        [Frozen] Mock<IAutoParsingService<TestData>> autoParsingServiceMock,
+        [Frozen] Mock<IDataReceiver<TestData>> dataReceiverMock,
+        DataProcessingService<TestData> dataProcessingService)
+    {
+        parsingResult.Success = true;
+        autoParsingServiceMock
+            .Setup(s => s.AutoParseAsync(goodInput))
+            .ReturnsAsync(parsingResult);
+
+        var result = await dataProcessingService.ProcessAsync(goodInput);
+
+        dataReceiverMock.Verify(r => r.ReceiveAsync(parsingResult.Data), Times.Once);
+        result.Should().BeSameAs(parsingResult);
+    }
+
     [Theory, AutoMoqData]
     public void Process_FailedParsing_NotSendToReceiver(
         string badInput,
@@ -50,4 +69,23 @@ public void Process_FailedParsing_NotSendToReceiver(
         dataReceiverMock.Verify(r => r.Receive(It.IsAny<TestData>()), Times.Never);
         result.Should().BeSameAs(parsingResult);
     }
+
+    [Theory, AutoMoqData]
+    public async Task ProcessAsync_FailedAsyncParsing_NotSendToReceiverAsync(
+        string badInput,
+        ParsingResult<TestData> parsingResult,
+        [Frozen] Mock<IAutoParsingService<TestData>> autoParsingServiceMock,
+        [Frozen] Mock<IDataReceiver<TestData>> dataReceiverMock,
+        DataProcessingService<TestData> dataProcessingService)
+    {
+        parsingResult.Success = false;
+        autoParsingServiceMock
+            .Setup(s => s.AutoParseAsync(badInput))
+            .ReturnsAsync(parsingResult);
+
+        var result = await dataProcessingService.ProcessAsync(badInput);
+
+        dataReceiverMock.Verify(r => r.ReceiveAsync(It.IsAny<TestData>()), Times.Never);
+        result.Should().BeSameAs(parsingResult);
+    }
 }
diff --git a/RealTimeWeatherMonitoringTest/Application/Service/MonitoringServiceShould.cs b/RealTimeWeatherMonitoringTest/Application/Service/MonitoringServiceShould.cs
@@ -26,6 +26,21 @@ public void Receive_Always_InvokeSubscribers(
             Times.Once);
     }
 
+    [Theory, AutoMoqData]
+    public async Task ReceiveAsync_Always_InvokeSubscribers(
+        TestData data,
+        Mock<EventHandler<DataChangeEventArgs<TestData>>> mockEventHandler,
+        MonitoringService<TestData> monitoringService)
+    {
+        monitoringService.OnDataChange += mockEventHandler.Object;
+
+        await monitoringService.ReceiveAsync(data);
+
+        mockEventHandler.Verify(
+            h => h.Invoke(It.IsAny<object>(), It.IsAny<DataChangeEventArgs<TestData>>()),
+            Times.Once);
+    }
+
     [Theory, AutoData]
     public void Receive_Always_SendSubscribersTheSameData(
         TestData data,
@@ -39,4 +54,18 @@ public void Receive_Always_SendSubscribersTheSameData(
         capturedEventArgs.Should().NotBeNull();
         capturedEventArgs.NewData.Should().BeSameAs(data);
     }
+
+    [Theory, AutoData]
+    public async Task ReceiveAsync_Always_SendSubscribersTheSameData(
+        TestData data,
+        MonitoringService<TestData> monitoringService)
+    {
+        DataChangeEventArgs<TestData>? capturedEventArgs = null;
+        monitoringService.OnDataChange += (_, args) => capturedEventArgs = args;
+
+        await monitoringService.ReceiveAsync(data);
+
+        capturedEventArgs.Should().NotBeNull();
+        capturedEventArgs.NewData.Should().BeSameAs(data);
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,4 +7,6 @@ namespace RealTimeWeatherMonitoringApp.Application.Interfaces;`
`7`	`7`	`public interface IDataReceiver<in TReceived>`
`8`	`8`	`{`
`9`	`9`	`void Receive(TReceived? data);`
	`10`	`+`
	`11`	`+ Task ReceiveAsync(TReceived? data);`
`10`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,7 @@ public ParsingResult<TResult> AutoParse(string input)`
`23`	`23`
`24`	`24`	`return new ParsingResult<TResult>(false, $"No valid parsing strategy was found for input '{input}'");`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ public async Task<ParsingResult<TResult>> AutoParseAsync(string input) =>`
	`28`	`+ await Task.Run(() => AutoParse(input));`
`26`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,4 +21,12 @@ public ParsingResult<TData> Process(string input)`
`21`	`21`	`if (result.Success) _receiver.Receive(result.Data);`
`22`	`22`	`return result;`
`23`	`23`	`}`
	`24`	`+`
	`25`	`+ public async Task<ParsingResult<TData>> ProcessAsync(string input)`
	`26`	`+ {`
	`27`	`+ var result = await _autoParsingService.AutoParseAsync(input);`
	`28`	`+ if (result.Success)`
	`29`	`+ await _receiver.ReceiveAsync(result.Data);`
	`30`	`+ return result;`
	`31`	`+ }`
`24`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,5 +12,7 @@ public class MonitoringService<TData> : IDataReceiver<TData>, IDataChangeNotifie`
`12`	`12`	`public void Receive(TData? data) =>`
`13`	`13`	`OnDataChange?.Invoke(this, new DataChangeEventArgs<TData>(data));`
`14`	`14`
	`15`	`+ public async Task ReceiveAsync(TData? data) => await Task.Run(() => Receive(data));`
	`16`	`+`
`15`	`17`	`public event EventHandler<DataChangeEventArgs<TData>>? OnDataChange;`
`16`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public UserController(`
`16`	`16`	`_weatherDataProcessor = weatherDataProcessor;`
`17`	`17`	`}`
`18`	`18`
`19`		`- public void Start()`
	`19`	`+ public async Task Start()`
`20`	`20`	`{`
`21`	`21`	`_botNotificationService.OnBotNotification += (_, args) =>`
`22`	`22`	`Console.WriteLine($"\n{args.BotName}: {args.Message}");`
`@@ -34,7 +34,7 @@ public void Start()`
`34`	`34`	`var input = Console.ReadLine() ?? string.Empty;`
`35`	`35`	`if (input.Equals("q", StringComparison.CurrentCultureIgnoreCase)) break;`
`36`	`36`
`37`		`- var result = _weatherDataProcessor.Process(input);`
	`37`	`+ var result = await _weatherDataProcessor.ProcessAsync(input);`
`38`	`38`	`if (result.Fail) Console.WriteLine(result.Message);`
`39`	`39`	`}`
`40`	`40`	`}`