Merge pull request #16 from 0neDistruktion/lab8Fix

Lab8 fix

Author: 0neDistruktion

.github/workflows/sonarcloud.yml

@@ -47,4 +47,4 @@ jobs:
       # 4) END: SonarScanner
       - name: SonarScanner End
         run: dotnet sonarscanner end /d:sonar.token="${{ secrets.SONAR_TOKEN }}"
-        shell: pwsh
+        shell: pwsh

EchoTcpServer/EchoServer.cs

@@ -5,14 +5,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-// Додаємо namespace, щоб тести могли його бачити
 namespace EchoTcpServerApp.Server
 {
     public class EchoServer
     {
         private readonly int _port;
-        private TcpListener _listener;
-        private CancellationTokenSource _cancellationTokenSource;
+        private TcpListener? _listener; // Nullable
+        private readonly CancellationTokenSource _cancellationTokenSource; // Readonly
 
         public EchoServer(int port)
         {
@@ -30,65 +29,65 @@ public async Task StartAsync()
             {
                 try
                 {
-                    TcpClient client = await _listener.AcceptTcpClientAsync();
+                    if (_listener == null) break; 
+                    TcpClient client = await _listener.AcceptTcpClientAsync(_cancellationTokenSource.Token);
                     Console.WriteLine("Client connected.");
 
-                    // Викликаємо приватний обробник
+                    // Викликаємо статичний обробник
                     _ = Task.Run(() => HandleClientAsync(client, _cancellationTokenSource.Token));
                 }
-                catch (ObjectDisposedException)
+                catch (OperationCanceledException)
                 {
                     break;
                 }
+                catch (Exception ex)
+                {
+                     Console.WriteLine($"Accept error: {ex.Message}");
+                }
             }
             Console.WriteLine("Server shutdown.");
         }
 
-        // Цей приватний метод керує з'єднанням
-        private async Task HandleClientAsync(TcpClient client, CancellationToken token)
+        // Smell fix: Made static
+        private static async Task HandleClientAsync(TcpClient client, CancellationToken token)
         {
+            using (client)
             using (NetworkStream stream = client.GetStream())
             {
                 try
                 {
-                    // РЕФАКТОРИНГ
-                    // Ми викликаємо нашу нову ТЕСТОВАНУ логіку
                     await EchoStreamAsync(stream, token);
-                    
                 }
-                catch (Exception ex) when (!(ex is OperationCanceledException))
+                catch (Exception ex) when (ex is not OperationCanceledException)
                 {
                     Console.WriteLine($"Error: {ex.Message}");
                 }
                 finally
                 {
-                    client.Close();
                     Console.WriteLine("Client disconnected.");
                 }
             }
         }
 
-        // НОВИЙ МЕТОД ДЛЯ ТЕСТІВ
-        // Цей публічний, статичний метод містить тільки логіку "ехо".
-        // Він нічого не знає про TcpClient, тому ми можемо його легко протестувати.
         public static async Task EchoStreamAsync(Stream stream, CancellationToken token)
         {
             byte[] buffer = new byte[8192];
             int bytesRead;
 
-            while (!token.IsCancellationRequested && (bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, token)) > 0)
+            // Smell fix: Using ReadAsync(Memory<byte>, CancellationToken) implicitly
+            while (!token.IsCancellationRequested && 
+                   (bytesRead = await stream.ReadAsync(buffer, token)) > 0)
             {
-                // Echo back the received message
-                await stream.WriteAsync(buffer, 0, bytesRead, token);
+                // Smell fix: Using WriteAsync(ReadOnlyMemory<byte>, CancellationToken) implicitly
+                await stream.WriteAsync(buffer.AsMemory(0, bytesRead), token);
                 Console.WriteLine($"Echoed {bytesRead} bytes to the client.");
             }
         }
-  
 
         public void Stop()
         {
             _cancellationTokenSource.Cancel();
-            _listener.Stop();
+            _listener?.Stop();
             _cancellationTokenSource.Dispose();
             Console.WriteLine("Server stopped.");
         }

EchoTcpServer/EchoServer.csproj

@@ -7,4 +7,4 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
-</Project>
+</Project>

EchoTcpServer/UdpTimedSender.cs

@@ -4,15 +4,14 @@
 using System.Net.Sockets;
 using System.Threading;
 
-// Додаємо namespace
 namespace EchoTcpServerApp.Client
 {
     public class UdpTimedSender : IDisposable
     {
         private readonly string _host;
         private readonly int _port;
         private readonly UdpClient _udpClient;
-        private Timer _timer;
+        private Timer? _timer; // Nullable
 
         public UdpTimedSender(string host, int port)
         {
@@ -29,19 +28,21 @@ public void StartSending(int intervalMilliseconds)
             _timer = new Timer(SendMessageCallback, null, 0, intervalMilliseconds);
         }
 
-        ushort i = 0;
+        ushort _counter = 0;
 
-        private void SendMessageCallback(object state)
+        // Smell fix: state is nullable
+        private void SendMessageCallback(object? state)
         {
             try
             {
-                //dummy data
-                Random rnd = new Random();
                 byte[] samples = new byte[1024];
-                rnd.NextBytes(samples);
-                i++;
+                Random.Shared.NextBytes(samples);
+                _counter++;
 
-                byte[] msg = (new byte[] { 0x04, 0x84 }).Concat(BitConverter.GetBytes(i)).Concat(samples).ToArray();
+                byte[] msg = (new byte[] { 0x04, 0x84 })
+                             .Concat(BitConverter.GetBytes(_counter))
+                             .Concat(samples).ToArray();
+                             
                 var endpoint = new IPEndPoint(IPAddress.Parse(_host), _port);
 
                 _udpClient.Send(msg, msg.Length, endpoint);
@@ -61,8 +62,17 @@ public void StopSending()
 
         public void Dispose()
         {
-            StopSending();
-            _udpClient.Dispose();
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                StopSending();
+                _udpClient.Dispose();
+            }
         }
     }
 }

EchoTcpServerTests/EchoServerIntegrationTests.cs

@@ -0,0 +1,56 @@
+using NUnit.Framework;
+using EchoTcpServerApp.Server;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading.Tasks;
+using System;
+
+namespace EchoTcpServerTests
+{
+    [TestFixture]
+    public class EchoServerIntegrationTests
+    {
+        [Test]
+        public async Task Server_Should_AcceptClient_And_EchoMessage_RealConnection()
+        {
+            // 1. Arrange: Запускаємо сервер на тестовому порту
+            int port = 55555;
+            var server = new EchoServer(port);
+            
+            // Запускаємо сервер у фоні (не чекаємо await, бо він заблокує тест)
+            var serverTask = server.StartAsync();
+
+            // Даємо серверу трохи часу на старт
+            await Task.Delay(100);
+
+            try
+            {
+                // 2. Act: Створюємо справжнього TCP клієнта і підключаємося
+                using var client = new TcpClient();
+                await client.ConnectAsync("127.0.0.1", port);
+
+                // Відправляємо повідомлення
+                var stream = client.GetStream();
+                string message = "Integration Test Data";
+                byte[] data = Encoding.UTF8.GetBytes(message);
+                await stream.WriteAsync(data, 0, data.Length);
+
+                // Читаємо відповідь (Ехо)
+                byte[] buffer = new byte[1024];
+                int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
+                string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
+
+                // 3. Assert: Сервер мав повернути те саме
+                Assert.That(response, Is.EqualTo(message));
+            }
+            finally
+            {
+                // 4. Cleanup: Зупиняємо сервер
+                server.Stop();
+                
+                // Ігноруємо помилки скасування задачі, це нормально при зупинці
+                try { await serverTask; } catch { }
+            }
+        }
+    }
+}

EchoTcpServerTests/EchoServerTests.cs

@@ -1,5 +1,7 @@
 using NUnit.Framework;
+using System;
 using System.IO;
+using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,57 +11,87 @@ namespace EchoTcpServerTests
 {
     public class EchoServerTests
     {
-        [SetUp]
-        public void Setup()
-        {
-        }
-
         [Test]
         public async Task EchoStreamAsync_ShouldEchoBackMessage()
         {
-            // --- Arrange (Підготовка) ---
             var originalMessage = "Hello, World!";
             var messageBytes = Encoding.UTF8.GetBytes(originalMessage);
 
-            // Створюємо потік і записуємо туди "вхідні" дані як байти
-            var stream = new MemoryStream();
-            await stream.WriteAsync(messageBytes, 0, messageBytes.Length);
-
-            // "Перемотуємо" на початок, щоб сервер міг прочитати це як вхідні дані
+            using var stream = new MemoryStream();
+            await stream.WriteAsync(messageBytes);
             stream.Position = 0;
 
-            // --- Act (Дія) ---
-            // Запускаємо ехо. Воно прочитає дані і допише їх в кінець потоку.
             await EchoServer.EchoStreamAsync(stream, CancellationToken.None);
 
-            // --- Assert (Перевірка) ---
-            // Тепер у потоці має бути: [Вхідні дані] + [Ехо-відповідь]
-            
-            // Перемотуємо на початок і читаємо все разом
             stream.Position = 0;
             using var reader = new StreamReader(stream, Encoding.UTF8);
             var fullContent = await reader.ReadToEndAsync();
 
-            // Перевіряємо, що повний текст це "Hello, World!" + "Hello, World!"
-            Assert.AreEqual(originalMessage + originalMessage, fullContent);
+            Assert.That(fullContent, Is.EqualTo(originalMessage + originalMessage));
         }
 
         [Test]
         public async Task EchoStreamAsync_ShouldHandleEmptyMessage()
         {
-            // Arrange
-            var stream = new MemoryStream();
-            stream.Position = 0;
-
-            // Act
+            using var stream = new MemoryStream();
+            
             await EchoServer.EchoStreamAsync(stream, CancellationToken.None);
 
-            // Assert
             stream.Position = 0;
             using var reader = new StreamReader(stream, Encoding.UTF8);
             var actualMessage = await reader.ReadToEndAsync();
 
-            Assert.AreEqual(string.Empty, actualMessage);
+            Assert.That(actualMessage, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public async Task Stop_ShouldCancelServerLoop_Gracefully()
+        {
+            var server = new EchoServer(0); 
+            var serverTask = server.StartAsync();
+            
+            await Task.Delay(100);
+            server.Stop();
+            
+            Assert.DoesNotThrowAsync(async () => await serverTask);
+        }
+
+        [Test]
+        public async Task Integration_ServerShouldHandleRealTcpConnection()
+        {
+            int port = new Random().Next(50000, 60000);
+            var server = new EchoServer(port);
+            var serverTask = server.StartAsync();
+
+            await Task.Delay(100);
+
+            using (var client = new TcpClient())
+            {
+                await client.ConnectAsync("127.0.0.1", port);
+                using var stream = client.GetStream();
+
+                byte[] dataToSend = { 10, 20, 30 };
+                await stream.WriteAsync(dataToSend);
+
+                byte[] buffer = new byte[3];
+                
+                // FIX: Зберігаємо Task в змінну, щоб порівнювати посилання
+                var readValueTask = stream.ReadAsync(buffer);
+                var actualReadTask = readValueTask.AsTask();
+                
+                var completedTask = await Task.WhenAny(actualReadTask, Task.Delay(2000));
+
+                if (completedTask == actualReadTask)
+                {
+                    Assert.That(buffer, Is.EqualTo(dataToSend));
+                }
+                else
+                {
+                    Assert.Fail("Timeout waiting for echo response");
+                }
+            }
+            server.Stop();
+            Assert.DoesNotThrowAsync(async () => await serverTask);
         }
     }
 }