UseCases, Commands and unit tests for system.drives added

.idea/.idea.RackPeek/.idea/.name

@@ -1 +0,0 @@
-RackPeek

RackPeek.Domain/Resources/SystemResources/UseCases/AddSystemDriveUseCase.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+
+namespace RackPeek.Domain.Resources.SystemResources.UseCases;
+
+public class AddSystemDriveUseCase(ISystemRepository repository) : IUseCase
+{
+    public async Task ExecuteAsync(string systemName, string type, int size)
+    {
+        ThrowIfInvalid.ResourceName(systemName);
+        ThrowIfInvalid.ResourceName(type);
+
+        if (size < 0)
+            throw new ValidationException("Drive size must be a non‑negative number of gigabytes.");
+
+        var system = await repository.GetByNameAsync(systemName)
+                     ?? throw new NotFoundException($"System '{systemName}' not found.");
+
+        system.Drives ??= new List<Drive>();
+
+        if (system.Drives.Any(d => d.Type == type))
+            throw new ConflictException($"Drive '{type}' already exists on system '{systemName}'.");
+
+        system.Drives.Add(new Drive
+        {
+            Type = type,
+            Size = size
+        });
+
+        await repository.UpdateAsync(system);
+    }
+}

RackPeek.Domain/Resources/SystemResources/UseCases/RemoveSystemDriveUseCase.cs

@@ -0,0 +1,24 @@
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+
+namespace RackPeek.Domain.Resources.SystemResources.UseCases;
+
+public class RemoveSystemDriveUseCase(ISystemRepository repository) : IUseCase
+{
+    public async Task ExecuteAsync(string systemName, string type)
+    {
+        ThrowIfInvalid.ResourceName(systemName);
+        ThrowIfInvalid.ResourceName(type);
+
+        var system = await repository.GetByNameAsync(systemName)
+                     ?? throw new NotFoundException($"System '{systemName}' not found.");
+
+        var drive = system.Drives?.FirstOrDefault(d => d.Type == type)
+                    ?? throw new NotFoundException($"Drive '{type}' not found on system '{systemName}'.");
+
+        system.Drives!.Remove(drive);
+
+        await repository.UpdateAsync(system);
+    }
+}

RackPeek.Domain/Resources/SystemResources/UseCases/UpdateSystemDriveUseCase.cs

@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations;
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+
+namespace RackPeek.Domain.Resources.SystemResources.UseCases;
+
+public class UpdateSystemDriveUseCase(ISystemRepository repository) : IUseCase
+{
+    public async Task ExecuteAsync(string systemName, string type, int size)
+    {
+        ThrowIfInvalid.ResourceName(systemName);
+        ThrowIfInvalid.ResourceName(type);
+
+        if (size < 0)
+            throw new ValidationException("Drive size must be a non‑negative number of gigabytes.");
+
+        var system = await repository.GetByNameAsync(systemName)
+                     ?? throw new NotFoundException($"System '{systemName}' not found.");
+
+        var drive = system.Drives?.FirstOrDefault(d => d.Type == type)
+                    ?? throw new NotFoundException($"Drive '{type}' not found on system '{systemName}'.");
+
+        drive.Size = size;
+
+        await repository.UpdateAsync(system);
+    }
+}

RackPeek/Commands/Systems/Drives/SystemDriveAddCommand.cs

@@ -0,0 +1,38 @@
+using Microsoft.Extensions.DependencyInjection;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace RackPeek.Commands.Systems.Drives;
+
+public class SystemDriveAddCommand(IServiceProvider serviceProvider)
+    : AsyncCommand<SystemDriveAddCommand.Settings>
+{
+    public class Settings : CommandSettings
+    {
+        [CommandArgument(0, "<systemName>")]
+        public string SystemName { get; set; } = default!;
+
+        [CommandArgument(1, "<driveName>")]
+        public string DriveName { get; set; } = default!;
+
+        [CommandArgument(2, "<sizeGb>")]
+        public int SizeGb { get; set; }
+    }
+
+    public override async Task<int> ExecuteAsync(
+        CommandContext context,
+        Settings settings,
+        CancellationToken cancellationToken)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var useCase = scope.ServiceProvider.GetRequiredService<AddSystemDriveUseCase>();
+
+        await useCase.ExecuteAsync(settings.SystemName, settings.DriveName, settings.SizeGb);
+
+        AnsiConsole.MarkupLine(
+            $"[green]Drive '{settings.DriveName}' added to system '{settings.SystemName}'.[/]");
+
+        return 0;
+    }
+}

RackPeek/Commands/Systems/Drives/SystemDriveRemoveCommand.cs

@@ -0,0 +1,35 @@
+using Microsoft.Extensions.DependencyInjection;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace RackPeek.Commands.Systems.Drives;
+
+public class SystemDriveRemoveCommand(IServiceProvider serviceProvider)
+    : AsyncCommand<SystemDriveRemoveCommand.Settings>
+{
+    public class Settings : CommandSettings
+    {
+        [CommandArgument(0, "<systemName>")]
+        public string SystemName { get; set; } = default!;
+
+        [CommandArgument(1, "<driveName>")]
+        public string DriveName { get; set; } = default!;
+    }
+
+    public override async Task<int> ExecuteAsync(
+        CommandContext context,
+        Settings settings,
+        CancellationToken cancellationToken)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var useCase = scope.ServiceProvider.GetRequiredService<RemoveSystemDriveUseCase>();
+
+        await useCase.ExecuteAsync(settings.SystemName, settings.DriveName);
+
+        AnsiConsole.MarkupLine(
+            $"[green]Drive '{settings.DriveName}' removed from system '{settings.SystemName}'.[/]");
+
+        return 0;
+    }
+}

RackPeek/Commands/Systems/Drives/SystemDriveUpdateCommand.cs

@@ -0,0 +1,38 @@
+using Microsoft.Extensions.DependencyInjection;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace RackPeek.Commands.Systems.Drives;
+
+public class SystemDriveUpdateCommand(IServiceProvider serviceProvider)
+    : AsyncCommand<SystemDriveUpdateCommand.Settings>
+{
+    public class Settings : CommandSettings
+    {
+        [CommandArgument(0, "<systemName>")]
+        public string SystemName { get; set; } = default!;
+
+        [CommandArgument(1, "<driveName>")]
+        public string DriveName { get; set; } = default!;
+
+        [CommandArgument(2, "<sizeGb>")]
+        public int SizeGb { get; set; }
+    }
+
+    public override async Task<int> ExecuteAsync(
+        CommandContext context,
+        Settings settings,
+        CancellationToken cancellationToken)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var useCase = scope.ServiceProvider.GetRequiredService<UpdateSystemDriveUseCase>();
+
+        await useCase.ExecuteAsync(settings.SystemName, settings.DriveName, settings.SizeGb);
+
+        AnsiConsole.MarkupLine(
+            $"[green]Drive '{settings.DriveName}' updated on system '{settings.SystemName}'.[/]");
+
+        return 0;
+    }
+}

Tests/HardwareResources/Systems/AddSystemDriveUseCaseTests.cs

@@ -0,0 +1,129 @@
+using System.ComponentModel.DataAnnotations;
+using NSubstitute;
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+
+namespace Tests.HardwareResources.Systems;
+
+public class AddSystemDriveUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Adds_drive_when_system_exists()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource
+        {
+            Name = "sys1",
+            Drives = new List<Drive>()
+        };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new AddSystemDriveUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("sys1", "ssd", 512);
+
+        // Assert
+        Assert.Single(system.Drives);
+        Assert.Equal("ssd", system.Drives[0].Type);
+        Assert.Equal(512, system.Drives[0].Size);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<SystemResource>(s =>
+            s.Name == "sys1" &&
+            s.Drives.Count == 1 &&
+            s.Drives[0].Type == "ssd" &&
+            s.Drives[0].Size == 512
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Initializes_drive_list_when_null()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource
+        {
+            Name = "sys1",
+            Drives = null
+        };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new AddSystemDriveUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("sys1", "sata", 500);
+
+        // Assert
+        Assert.NotNull(system.Drives);
+        Assert.Single(system.Drives);
+
+        await repo.Received(1).UpdateAsync(Arg.Is<SystemResource>(s =>
+            s.Drives != null &&
+            s.Drives.Count == 1 &&
+            s.Drives[0].Type == "sata"
+        ));
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_system_not_found()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        repo.GetByNameAsync("sys1").Returns((SystemResource?)null);
+
+        var sut = new AddSystemDriveUseCase(repo);
+
+        // Act + Assert
+        await Assert.ThrowsAsync<NotFoundException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_drive_already_exists()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource
+        {
+            Name = "sys1",
+            Drives = new List<Drive> { new() { Type = "ssd", Size = 256 } }
+        };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new AddSystemDriveUseCase(repo);
+
+        // Act + Assert
+        await Assert.ThrowsAsync<ConflictException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_type_invalid()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var sut = new AddSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<ValidationException>(() =>
+            sut.ExecuteAsync("sys1", "", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_size_negative()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var sut = new AddSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<ValidationException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", -1)
+        );
+    }
+}

Tests/HardwareResources/Systems/RemoveSystemDriveUseCaseTests.cs

@@ -0,0 +1,75 @@
+using System.ComponentModel.DataAnnotations;
+using NSubstitute;
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+
+namespace Tests.HardwareResources.Systems;
+
+public class RemoveSystemDriveUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Removes_drive_when_found()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        var drive = new Drive { Type = "ssd", Size = 256 };
+        var system = new SystemResource
+        {
+            Name = "sys1",
+            Drives = new List<Drive> { drive }
+        };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new RemoveSystemDriveUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("sys1", "ssd");
+
+        // Assert
+        Assert.Empty(system.Drives);
+
+        await repo.Received(1).UpdateAsync(system);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_system_not_found()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        repo.GetByNameAsync("sys1").Returns((SystemResource?)null);
+
+        var sut = new RemoveSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<NotFoundException>(() =>
+            sut.ExecuteAsync("sys1", "ssd")
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_drive_not_found()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource { Name = "sys1", Drives = new List<Drive>() };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new RemoveSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<NotFoundException>(() =>
+            sut.ExecuteAsync("sys1", "ssd")
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_type_invalid()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var sut = new RemoveSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<ValidationException>(() =>
+            sut.ExecuteAsync("sys1", "")
+        );
+    }
+}

Tests/HardwareResources/Systems/UpdateSystemDriveUseCaseTests.cs

@@ -0,0 +1,85 @@
+using System.ComponentModel.DataAnnotations;
+using NSubstitute;
+using RackPeek.Domain.Helpers;
+using RackPeek.Domain.Resources.Hardware.Models;
+using RackPeek.Domain.Resources.SystemResources;
+using RackPeek.Domain.Resources.SystemResources.UseCases;
+
+namespace Tests.HardwareResources.Systems;
+
+public class UpdateSystemDriveUseCaseTests
+{
+    [Fact]
+    public async Task ExecuteAsync_Updates_drive_when_found()
+    {
+        // Arrange
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource
+        {
+            Name = "sys1",
+            Drives = new List<Drive> { new() { Type = "ssd", Size = 256 } }
+        };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new UpdateSystemDriveUseCase(repo);
+
+        // Act
+        await sut.ExecuteAsync("sys1", "ssd", 512);
+
+        // Assert
+        Assert.Equal(512, system.Drives[0].Size);
+
+        await repo.Received(1).UpdateAsync(system);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_system_not_found()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        repo.GetByNameAsync("sys1").Returns((SystemResource?)null);
+
+        var sut = new UpdateSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<NotFoundException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_drive_not_found()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var system = new SystemResource { Name = "sys1", Drives = new List<Drive>() };
+
+        repo.GetByNameAsync("sys1").Returns(system);
+
+        var sut = new UpdateSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<NotFoundException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_type_invalid()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var sut = new UpdateSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<ValidationException>(() =>
+            sut.ExecuteAsync("sys1", "", 512)
+        );
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_Throws_when_size_negative()
+    {
+        var repo = Substitute.For<ISystemRepository>();
+        var sut = new UpdateSystemDriveUseCase(repo);
+
+        await Assert.ThrowsAsync<ValidationException>(() =>
+            sut.ExecuteAsync("sys1", "ssd", -1)
+        );
+    }
+}