remove k8s configs, update worker for multi-languages support, add local-submit option

tests/LiquidCode.Tester.Worker.Tests/CompilationServiceFactoryTests.cs

@@ -0,0 +1,128 @@
+using LiquidCode.Tester.Worker.Services;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace LiquidCode.Tester.Worker.Tests;
+
+public class CompilationServiceFactoryTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly CompilationServiceFactory _factory;
+
+    public CompilationServiceFactoryTests()
+    {
+        var services = new ServiceCollection();
+
+        // Mock configuration
+        var configuration = new Mock<IConfiguration>();
+        services.AddSingleton(configuration.Object);
+
+        // Mock logger
+        var loggerFactory = new Mock<ILoggerFactory>();
+        loggerFactory.Setup(x => x.CreateLogger(It.IsAny<string>()))
+            .Returns(new Mock<ILogger>().Object);
+        services.AddSingleton(loggerFactory.Object);
+        services.AddLogging();
+
+        // Register compilation services
+        services.AddSingleton<CppCompilationService>();
+        services.AddSingleton<JavaCompilationService>();
+        services.AddSingleton<KotlinCompilationService>();
+        services.AddSingleton<CSharpCompilationService>();
+        services.AddSingleton<PythonCompilationService>();
+
+        _serviceProvider = services.BuildServiceProvider();
+        _factory = new CompilationServiceFactory(
+            _serviceProvider,
+            _serviceProvider.GetRequiredService<ILogger<CompilationServiceFactory>>());
+    }
+
+    [Theory]
+    [InlineData("C++", typeof(CppCompilationService))]
+    [InlineData("c++", typeof(CppCompilationService))]
+    [InlineData("cpp", typeof(CppCompilationService))]
+    [InlineData("CPP", typeof(CppCompilationService))]
+    public void GetCompilationService_CppLanguage_ReturnsCppCompilationService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetCompilationService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Java", typeof(JavaCompilationService))]
+    [InlineData("java", typeof(JavaCompilationService))]
+    [InlineData("JAVA", typeof(JavaCompilationService))]
+    public void GetCompilationService_JavaLanguage_ReturnsJavaCompilationService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetCompilationService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Kotlin", typeof(KotlinCompilationService))]
+    [InlineData("kotlin", typeof(KotlinCompilationService))]
+    [InlineData("KOTLIN", typeof(KotlinCompilationService))]
+    public void GetCompilationService_KotlinLanguage_ReturnsKotlinCompilationService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetCompilationService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("C#", typeof(CSharpCompilationService))]
+    [InlineData("c#", typeof(CSharpCompilationService))]
+    [InlineData("csharp", typeof(CSharpCompilationService))]
+    [InlineData("CSharp", typeof(CSharpCompilationService))]
+    [InlineData("CSHARP", typeof(CSharpCompilationService))]
+    public void GetCompilationService_CSharpLanguage_ReturnsCSharpCompilationService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetCompilationService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Python", typeof(PythonCompilationService))]
+    [InlineData("python", typeof(PythonCompilationService))]
+    [InlineData("PYTHON", typeof(PythonCompilationService))]
+    public void GetCompilationService_PythonLanguage_ReturnsPythonCompilationService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetCompilationService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Go")]
+    [InlineData("Rust")]
+    [InlineData("JavaScript")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void GetCompilationService_UnsupportedLanguage_ThrowsNotSupportedException(string language)
+    {
+        // Act & Assert
+        Assert.Throws<NotSupportedException>(() => _factory.GetCompilationService(language));
+    }
+
+    [Fact]
+    public void GetCompilationService_NullLanguage_ThrowsException()
+    {
+        // Act & Assert
+        Assert.Throws<NullReferenceException>(() => _factory.GetCompilationService(null!));
+    }
+}