Added Server CPU usecase tests

RackPeek/servers.yaml

@@ -394,22 +394,4 @@ resources:
   gpus: 
   ipmi: true
   name: dell-r730-archive01
-  tags: 
-- kind: Server
-  cpus: 
-  ram: 
-  drives: 
-  nics: 
-  gpus: 
-  ipmi: 
-  name: noe01
-  tags: 
-- kind: Server
-  cpus: []
-  ram: 
-  drives: 
-  nics: 
-  gpus: 
-  ipmi: 
-  name: node01
-  tags: 
+  tags: 

Tests/Hardware/AddCpuUseCaseTests.cs

@@ -0,0 +1,101 @@
+using NSubstitute;
+using RackPeek.Domain.Resources.Hardware;
+using RackPeek.Domain.Resources.Hardware.Server.Cpu;
+
+namespace Tests.Hardware;
+
+public class AddCpuUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Adds_cpu_when_server_exists()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new RackPeek.Domain.Resources.Hardware.Models.Server
+        {
+            Name = "node01",
+            Cpus = new List<RackPeek.Domain.Resources.Hardware.Models.Cpu>()
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new AddCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync(
+            serverName: "node01",
+            model: "7950x",
+            cores: 8,
+            threads: 16
+        );
+
+        // Assert
+        Assert.Single(server.Cpus);
+        Assert.Equal("7950x", server.Cpus[0].Model);
+        Assert.Equal(8, server.Cpus[0].Cores);
+        Assert.Equal(16, server.Cpus[0].Threads);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<RackPeek.Domain.Resources.Hardware.Models.Server>(s =>
+            s.Name == "node01" &&
+            s.Cpus.Count == 1 &&
+            s.Cpus[0].Model == "7950x" &&
+            s.Cpus[0].Cores == 8 &&
+            s.Cpus[0].Threads == 16
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Initializes_cpu_list_when_null()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new RackPeek.Domain.Resources.Hardware.Models.Server
+        {
+            Name = "node01",
+            Cpus = null
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new AddCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync(
+            serverName: "node01",
+            model: "7950x",
+            cores: 8,
+            threads: 16
+        );
+
+        // Assert
+        Assert.NotNull(server.Cpus);
+        Assert.Single(server.Cpus);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<RackPeek.Domain.Resources.Hardware.Models.Server>(s =>
+            s.Cpus != null &&
+            s.Cpus.Count == 1 &&
+            s.Cpus[0].Model == "7950x"
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Does_nothing_when_server_does_not_exist()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        repo.GetByNameAsync("node01").Returns((RackPeek.Domain.Resources.Hardware.Models.Hardware?)null);
+
+        var sut = new AddCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync(
+            serverName: "node01",
+            model: "7950x",
+            cores: 8,
+            threads: 16
+        );
+
+        // Assert
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<RackPeek.Domain.Resources.Hardware.Models.Server>());
+    }
+}

Tests/Hardware/AddServerUseCaseTests.cs

@@ -1,6 +1,5 @@
 using NSubstitute;
 using RackPeek.Domain.Resources.Hardware;
-using RackPeek.Domain.Resources.Hardware.Models;
 using RackPeek.Domain.Resources.Hardware.Server;
 
 namespace Tests.Hardware;
@@ -22,7 +21,7 @@ public class AddServerUseCaseTests
         );
 
         // Assert
-        await repo.Received(1).AddAsync(Arg.Is<Server>(s =>
+        await repo.Received(1).AddAsync(Arg.Is<RackPeek.Domain.Resources.Hardware.Models.Server>(s =>
             s.Name == "node01"
         ));
     }
@@ -32,7 +31,7 @@ public class AddServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server { Name = "node01" });
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server { Name = "node01" });
 
         var sut = new AddServerUseCase(repo);
 
@@ -45,6 +44,6 @@ public class AddServerUseCaseTests
 
         // Assert
         Assert.Equal("Server 'node01' already exists.", ex.Message);
-        await repo.DidNotReceive().AddAsync(Arg.Any<Server>());
+        await repo.DidNotReceive().AddAsync(Arg.Any<RackPeek.Domain.Resources.Hardware.Models.Server>());
     }
 }

Tests/Hardware/DeleteServerUseCaseTests.cs

@@ -1,6 +1,5 @@
 using NSubstitute;
 using RackPeek.Domain.Resources.Hardware;
-using RackPeek.Domain.Resources.Hardware.Models;
 using RackPeek.Domain.Resources.Hardware.Server;
 
 namespace Tests.Hardware;
@@ -12,7 +11,7 @@ public class DeleteServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server { Name = "node01" });
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server { Name = "node01" });
 
         var sut = new DeleteServerUseCase(repo);
 

Tests/Hardware/DescribeServerUseCaseTests.cs

@@ -12,7 +12,7 @@ public class DescribeServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server
         {
             Name = "node01",
             Ipmi = true,

Tests/Hardware/GetServerUseCaseTests.cs

@@ -12,7 +12,7 @@ public class GetServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server { Name = "node01" });
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server { Name = "node01" });
 
         var sut = new GetServerUseCase(repo);
 
@@ -21,7 +21,7 @@ public class GetServerUseCaseTests
 
         // Assert
         Assert.NotNull(server);
-        Assert.IsType<Server>(server);
+        Assert.IsType<RackPeek.Domain.Resources.Hardware.Models.Server>(server);
         Assert.Equal("node01", server!.Name);
     }
 

Tests/Hardware/GetServersUseCaseTests.cs

@@ -14,9 +14,9 @@ public class GetServersUseCaseTests
         var repo = Substitute.For<IHardwareRepository>();
         repo.GetAllAsync().Returns(new List<RackPeek.Domain.Resources.Hardware.Models.Hardware>
         {
-            new Server { Name = "server1" },
+            new RackPeek.Domain.Resources.Hardware.Models.Server { Name = "server1" },
             new Desktop { Name = "desktop1" },
-            new Server { Name = "server2" }
+            new RackPeek.Domain.Resources.Hardware.Models.Server { Name = "server2" }
         });
 
         var sut = new GetServersUseCase(repo);
@@ -26,7 +26,7 @@ public class GetServersUseCaseTests
 
         // Assert
         Assert.Equal(2, servers.Count);
-        Assert.All(servers, s => Assert.IsType<Server>(s));
+        Assert.All(servers, s => Assert.IsType<RackPeek.Domain.Resources.Hardware.Models.Server>(s));
         Assert.Contains(servers, s => s.Name == "server1");
         Assert.Contains(servers, s => s.Name == "server2");
     }

Tests/Hardware/RemoveCpuUseCaseTests.cs

@@ -0,0 +1,85 @@
+using NSubstitute;
+using RackPeek.Domain.Resources.Hardware;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.Hardware.Server.Cpu;
+using Xunit;
+
+namespace Tests.Hardware;
+
+public class RemoveCpuUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Removes_cpu_when_index_is_valid()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new Server
+        {
+            Name = "node01",
+            Cpus = new List<Cpu>
+            {
+                new Cpu { Model = "7950x", Cores = 8, Threads = 16 },
+                new Cpu { Model = "7900x", Cores = 12, Threads = 24 }
+            }
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new RemoveCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("node01", index: 0);
+
+        // Assert
+        Assert.Single(server.Cpus);
+        Assert.Equal("7900x", server.Cpus[0].Model);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<Server>(s =>
+            s.Name == "node01" &&
+            s.Cpus.Count == 1 &&
+            s.Cpus[0].Model == "7900x"
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_if_index_out_of_range()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new Server
+        {
+            Name = "node01",
+            Cpus = new List<Cpu>
+            {
+                new Cpu { Model = "7950x", Cores = 8, Threads = 16 }
+            }
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new RemoveCpuUseCase(repo);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () =>
+            await sut.ExecuteAsync("node01", index: 1)
+        );
+
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<Server>());
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Does_nothing_when_server_does_not_exist()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        repo.GetByNameAsync("node01").Returns((RackPeek.Domain.Resources.Hardware.Models.Hardware?)null);
+
+        var sut = new RemoveCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("node01", index: 0);
+
+        // Assert
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<RackPeek.Domain.Resources.Hardware.Models.Server>());
+    }
+}

Tests/Hardware/ServerHardwareReportTests.cs

@@ -12,7 +12,7 @@ public class ServerHardwareReportTests
     {
         var repo = Substitute.For<IHardwareRepository>();
         repo.GetAllAsync().Returns([
-            new Server
+            new RackPeek.Domain.Resources.Hardware.Models.Server
             {
                 Name = "srv1",
                 Ipmi = true,

Tests/Hardware/UpdateCpuUseCaseTests.cs

@@ -0,0 +1,105 @@
+using NSubstitute;
+using RackPeek.Domain.Resources.Hardware;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.Hardware.Server.Cpu;
+using Xunit;
+
+namespace Tests.Hardware;
+
+public class UpdateCpuUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Updates_cpu_when_index_is_valid()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new Server
+        {
+            Name = "node01",
+            Cpus = new List<Cpu>
+            {
+                new Cpu { Model = "7950x", Cores = 8, Threads = 16 }
+            }
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new UpdateCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync(
+            serverName: "node01",
+            index: 0,
+            model: "7900x",
+            cores: 12,
+            threads: 24
+        );
+
+        // Assert
+        Assert.Equal("7900x", server.Cpus[0].Model);
+        Assert.Equal(12, server.Cpus[0].Cores);
+        Assert.Equal(24, server.Cpus[0].Threads);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<Server>(s =>
+            s.Name == "node01" &&
+            s.Cpus.Count == 1 &&
+            s.Cpus[0].Model == "7900x" &&
+            s.Cpus[0].Cores == 12 &&
+            s.Cpus[0].Threads == 24
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_if_index_out_of_range()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        var server = new Server
+        {
+            Name = "node01",
+            Cpus = new List<Cpu>
+            {
+                new Cpu { Model = "7950x", Cores = 8, Threads = 16 }
+            }
+        };
+
+        repo.GetByNameAsync("node01").Returns(server);
+
+        var sut = new UpdateCpuUseCase(repo);
+
+        // Act & Assert
+        await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () =>
+            await sut.ExecuteAsync(
+                serverName: "node01",
+                index: 1,
+                model: "7900x",
+                cores: 12,
+                threads: 24
+            )
+        );
+
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<Server>());
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Does_nothing_when_server_does_not_exist()
+    {
+        // Arrange
+        var repo = Substitute.For<IHardwareRepository>();
+        repo.GetByNameAsync("node01").Returns((RackPeek.Domain.Resources.Hardware.Models.Hardware?)null);
+
+        var sut = new UpdateCpuUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync(
+            serverName: "node01",
+            index: 0,
+            model: "7900x",
+            cores: 12,
+            threads: 24
+        );
+
+        // Assert
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<Server>());
+    }
+}

Tests/Hardware/UpdateServerUseCaseTests.cs

@@ -12,7 +12,7 @@ public class UpdateServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server
         {
             Name = "node01",
             Ipmi = false,
@@ -33,7 +33,7 @@ public class UpdateServerUseCaseTests
         );
 
         // Assert
-        await repo.Received(1).UpdateAsync(Arg.Is<Server>(s =>
+        await repo.Received(1).UpdateAsync(Arg.Is<RackPeek.Domain.Resources.Hardware.Models.Server>(s =>
             s.Name == "node01" &&
             s.Ram.Size == 64 &&
             s.Ipmi == true
@@ -56,7 +56,7 @@ public class UpdateServerUseCaseTests
 
         // Assert
         Assert.Equal("Server 'node01' not found.", ex.Message);
-        await repo.DidNotReceive().UpdateAsync(Arg.Any<Server>());
+        await repo.DidNotReceive().UpdateAsync(Arg.Any<RackPeek.Domain.Resources.Hardware.Models.Server>());
     }
 
     [Fact]
@@ -64,7 +64,7 @@ public class UpdateServerUseCaseTests
     {
         // Arrange
         var repo = Substitute.For<IHardwareRepository>();
-        repo.GetByNameAsync("node01").Returns(new Server
+        repo.GetByNameAsync("node01").Returns(new RackPeek.Domain.Resources.Hardware.Models.Server
         {
             Name = "node01",
             Ipmi = false,
@@ -85,7 +85,7 @@ public class UpdateServerUseCaseTests
         );
 
         // Assert
-        await repo.Received(1).UpdateAsync(Arg.Is<Server>(s =>
+        await repo.Received(1).UpdateAsync(Arg.Is<RackPeek.Domain.Resources.Hardware.Models.Server>(s =>
             s.Ram.Size == 32 &&
             s.Ipmi == false
         ));