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

tests/LiquidCode.Tester.Worker.Tests/ExecutionServiceFactoryTests.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 ExecutionServiceFactoryTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ExecutionServiceFactory _factory;
+
+    public ExecutionServiceFactoryTests()
+    {
+        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 execution services
+        services.AddSingleton<CppExecutionService>();
+        services.AddSingleton<JavaExecutionService>();
+        services.AddSingleton<KotlinExecutionService>();
+        services.AddSingleton<CSharpExecutionService>();
+        services.AddSingleton<PythonExecutionService>();
+
+        _serviceProvider = services.BuildServiceProvider();
+        _factory = new ExecutionServiceFactory(
+            _serviceProvider,
+            _serviceProvider.GetRequiredService<ILogger<ExecutionServiceFactory>>());
+    }
+
+    [Theory]
+    [InlineData("C++", typeof(CppExecutionService))]
+    [InlineData("c++", typeof(CppExecutionService))]
+    [InlineData("cpp", typeof(CppExecutionService))]
+    [InlineData("CPP", typeof(CppExecutionService))]
+    public void GetExecutionService_CppLanguage_ReturnsCppExecutionService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetExecutionService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Java", typeof(JavaExecutionService))]
+    [InlineData("java", typeof(JavaExecutionService))]
+    [InlineData("JAVA", typeof(JavaExecutionService))]
+    public void GetExecutionService_JavaLanguage_ReturnsJavaExecutionService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetExecutionService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Kotlin", typeof(KotlinExecutionService))]
+    [InlineData("kotlin", typeof(KotlinExecutionService))]
+    [InlineData("KOTLIN", typeof(KotlinExecutionService))]
+    public void GetExecutionService_KotlinLanguage_ReturnsKotlinExecutionService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetExecutionService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("C#", typeof(CSharpExecutionService))]
+    [InlineData("c#", typeof(CSharpExecutionService))]
+    [InlineData("csharp", typeof(CSharpExecutionService))]
+    [InlineData("CSharp", typeof(CSharpExecutionService))]
+    [InlineData("CSHARP", typeof(CSharpExecutionService))]
+    public void GetExecutionService_CSharpLanguage_ReturnsCSharpExecutionService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetExecutionService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Python", typeof(PythonExecutionService))]
+    [InlineData("python", typeof(PythonExecutionService))]
+    [InlineData("PYTHON", typeof(PythonExecutionService))]
+    public void GetExecutionService_PythonLanguage_ReturnsPythonExecutionService(string language, Type expectedType)
+    {
+        // Act
+        var service = _factory.GetExecutionService(language);
+
+        // Assert
+        Assert.IsType(expectedType, service);
+    }
+
+    [Theory]
+    [InlineData("Go")]
+    [InlineData("Rust")]
+    [InlineData("JavaScript")]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void GetExecutionService_UnsupportedLanguage_ThrowsNotSupportedException(string language)
+    {
+        // Act & Assert
+        Assert.Throws<NotSupportedException>(() => _factory.GetExecutionService(language));
+    }
+
+    [Fact]
+    public void GetExecutionService_NullLanguage_ThrowsException()
+    {
+        // Act & Assert
+        Assert.Throws<NullReferenceException>(() => _factory.GetExecutionService(null!));
+    }
+}