feat: working on adding abstractions

src/BGR.Console.Tests/BGR.Console.Tests.csproj

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="Shouldly" Version="4.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <PropertyGroup>
+    <CollectCoverage>true</CollectCoverage>
+    <CoverletOutput>./TestResults/coverage/</CoverletOutput>
+    <CoverletOutputFormat>cobertura</CoverletOutputFormat>
+    <Include>[BGR.Console]*</Include>
+    <ExcludeByFile>**/Program.cs</ExcludeByFile>
+  </PropertyGroup>
+
+  <Target Name="GenerateHtmlCoverageReport" AfterTargets="GenerateCoverageResultAfterTest">
+    <Exec Command="reportgenerator -reports:./TestResults/coverage/*.xml -targetdir:./TestResults/coverage/report/ -reporttypes:Html_Dark" />
+  </Target>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+    <Using Include="Shouldly" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BGR.Console\BGR.Console.csproj" />
+  </ItemGroup>
+
+</Project>

src/BGR.Console.Tests/Unit/ResourceManagerTests.cs

@@ -0,0 +1,26 @@
+namespace BGR.Console.Tests.Unit;
+
+public class ResourceManagerTests
+{
+  private readonly ResourceManager _resourceManager = new();
+
+  [Fact]
+  public void GetResource_WhenResourceExists_ItShouldReturnStream()
+  {
+    var resourceName = "u2net.onnx";
+
+    using var stream = _resourceManager.GetResource(resourceName);
+
+    stream.ShouldNotBeNull();
+  }
+
+  [Fact]
+  public void GetResource_WhenResourceDoesNotExist_ItShouldThrowException()
+  {
+    var resourceName = "nonexistent.onnx";
+
+    var act = () => _resourceManager.GetResource(resourceName);
+
+    act.ShouldThrow<FileNotFoundException>();
+  }
+}

src/BGR.Console.Tests/Unit/TypeRegistrarTests.cs

@@ -0,0 +1,84 @@
+namespace BGR.Console.Tests.Unit;
+
+public class TypeRegistrarTests
+{
+  [Fact]
+  public void Constructor_WhenCalled_ItShouldNotThrowShould()
+  {
+    var mockBuilder = new Mock<IHostBuilder>();
+
+    Should.NotThrow(() => new TypeRegistrar(mockBuilder.Object));
+  }
+
+  [Fact]
+  public void Build_WhenCalled_ItShouldReturnResolverAndBuildHost()
+  {
+    var mockHost = new Mock<IHost>();
+    var mockBuilder = new Mock<IHostBuilder>();
+
+    mockBuilder
+      .Setup(static b => b.Build())
+      .Returns(mockHost.Object);
+
+    var registrar = new TypeRegistrar(mockBuilder.Object);
+
+    var resolver = registrar.Build();
+
+    resolver.ShouldBeOfType<TypeResolver>();
+    mockBuilder.Verify(static b => b.Build(), Times.Once);
+  }
+
+  [Fact]
+  public void Register_WhenCalledWithType_ItShouldAddToContainer()
+  {
+    var builder = Host.CreateDefaultBuilder();
+    var registrar = new TypeRegistrar(builder);
+    registrar.Register(typeof(IService), typeof(ServiceImplementation));
+
+    using var host = builder.Build();
+    var service = host.Services.GetService<IService>();
+
+    service.ShouldNotBeNull();
+    service.ShouldBeOfType<ServiceImplementation>();
+  }
+
+  [Fact]
+  public void RegisterInstance_WhenCalledWithInstance_ItShouldAddToContainer()
+  {
+    var builder = Host.CreateDefaultBuilder();
+    var registrar = new TypeRegistrar(builder);
+    var instance = new ServiceImplementation();
+    registrar.RegisterInstance(typeof(IService), instance);
+
+    using var host = builder.Build();
+    var service = host.Services.GetService<IService>();
+
+    service.ShouldBeSameAs(instance);
+  }
+
+  [Fact]
+  public void RegisterLazy_WhenCalledWithFunc_ItShouldAddToContainer()
+  {
+    var builder = Host.CreateDefaultBuilder();
+    var registrar = new TypeRegistrar(builder);
+    registrar.RegisterLazy(typeof(IService), static () => new ServiceImplementation());
+
+    using var host = builder.Build();
+    var service = host.Services.GetService<IService>();
+
+    service.ShouldNotBeNull();
+    service.ShouldBeOfType<ServiceImplementation>();
+  }
+
+  [Fact]
+  public void RegisterLazy_WhenFuncIsNull_ItShouldThrow()
+  {
+    var builder = Host.CreateDefaultBuilder();
+    var registrar = new TypeRegistrar(builder);
+
+    Should.Throw<ArgumentNullException>(() => registrar.RegisterLazy(typeof(IService), null!));
+  }
+
+  private interface IService { }
+  private sealed class ServiceImplementation : IService { }
+}

src/BGR.Console.Tests/Unit/TypeResolverTests.cs

@@ -0,0 +1,71 @@
+namespace BGR.Console.Tests.Unit;
+
+public class TypeResolverTests
+{
+  [Fact]
+  public void Constructor_WhenCalledWithNullHost_ItShouldThrowArgumentNullException()
+  {
+    Should.Throw<ArgumentNullException>(static () => new TypeResolver(null!));
+  }
+
+  [Fact]
+  public void Resolve_WhenTypeIsNull_ItShouldReturnNull()
+  {
+    var mockHost = new Mock<IHost>();
+    using var resolver = new TypeResolver(mockHost.Object);
+
+    var result = resolver.Resolve(null);
+
+    result.ShouldBeNull();
+  }
+
+  [Fact]
+  public void Resolve_WhenCalledWithRegisteredType_ItShouldReturnAnInstance()
+  {
+    var services = new ServiceCollection();
+    services.AddSingleton(new TestService());
+
+    var mockHost = new Mock<IHost>();
+
+    mockHost
+      .Setup(static h => h.Services)
+      .Returns(services.BuildServiceProvider());
+
+    using var resolver = new TypeResolver(mockHost.Object);
+
+    var result = resolver.Resolve(typeof(TestService));
+
+    result.ShouldNotBeNull();
+    result.ShouldBeOfType<TestService>();
+  }
+
+  [Fact]
+  public void Resolve_WhenCalledWithUnregisteredType_ItShouldReturnNull()
+  {
+    var services = new ServiceCollection();
+    var mockHost = new Mock<IHost>();
+
+    mockHost
+      .Setup(static h => h.Services)
+      .Returns(services.BuildServiceProvider());
+
+    using var resolver = new TypeResolver(mockHost.Object);
+
+    var result = resolver.Resolve(typeof(TestService));
+
+    result.ShouldBeNull();
+  }
+
+  [Fact]
+  public void Dispose_WhenCalled_ItShouldAlsoDisposeHost()
+  {
+    var mockHost = new Mock<IHost>();
+    var resolver = new TypeResolver(mockHost.Object);
+
+    resolver.Dispose();
+
+    mockHost.Verify(static h => h.Dispose(), Times.Once);
+  }
+
+  private sealed class TestService { }
+}

src/BGR.Console.Tests/Usings.cs

@@ -0,0 +1,7 @@
+global using BGR.Console.Common;
+global using BGR.Console.Resources;
+
+global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Hosting;
+
+global using Moq;