Implement CLI tool with plugin system for file conversions

csharp/Platform.Converters.CLI.Tests/ConverterTests.cs

@@ -0,0 +1,164 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Platform.Converters.Plugins.Examples;
+using Xunit;
+
+namespace Platform.Converters.CLI.Tests
+{
+    /// <summary>
+    /// <para>Tests for converter implementations.</para>
+    /// <para>Тесты для реализаций конвертеров.</para>
+    /// </summary>
+    public class ConverterTests
+    {
+        /// <summary>
+        /// <para>Tests JSON to XML conversion.</para>
+        /// <para>Тестирует конверсию JSON в XML.</para>
+        /// </summary>
+        [Fact]
+        public async Task JsonToXmlConverter_ShouldConvertJsonToXml()
+        {
+            // Arrange
+            var converter = new JsonToXmlConverter();
+            var jsonContent = """{"name": "test", "value": 42, "active": true}""";
+            var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonContent));
+            var targetStream = new MemoryStream();
+
+            // Act
+            await converter.ConvertAsync(sourceStream, targetStream, ".json", ".xml");
+
+            // Assert
+            targetStream.Position = 0;
+            var result = Encoding.UTF8.GetString(targetStream.ToArray());
+
+            Assert.Contains("<name>test</name>", result);
+            Assert.Contains("<value>42</value>", result);
+            Assert.Contains("<active>true</active>", result);
+        }
+
+        /// <summary>
+        /// <para>Tests XML to JSON conversion.</para>
+        /// <para>Тестирует конверсию XML в JSON.</para>
+        /// </summary>
+        [Fact]
+        public async Task XmlToJsonConverter_ShouldConvertXmlToJson()
+        {
+            // Arrange
+            var converter = new XmlToJsonConverter();
+            var xmlContent = """
+                <?xml version="1.0"?>
+                <root>
+                    <name>test</name>
+                    <value>42</value>
+                    <active>true</active>
+                </root>
+                """;
+            var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));
+            var targetStream = new MemoryStream();
+
+            // Act
+            await converter.ConvertAsync(sourceStream, targetStream, ".xml", ".json");
+
+            // Assert
+            targetStream.Position = 0;
+            var result = Encoding.UTF8.GetString(targetStream.ToArray());
+
+            Assert.Contains("\"name\": \"test\"", result);
+            Assert.Contains("\"value\": 42", result);
+            Assert.Contains("\"active\": true", result);
+        }
+
+        /// <summary>
+        /// <para>Tests text case conversion to uppercase.</para>
+        /// <para>Тестирует конверсию регистра текста в верхний.</para>
+        /// </summary>
+        [Fact]
+        public async Task TextToUppercaseConverter_ShouldConvertToUppercase()
+        {
+            // Arrange
+            var converter = new TextToUppercaseConverter();
+            var textContent = "Hello World!\nThis is a test.";
+            var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(textContent));
+            var targetStream = new MemoryStream();
+
+            // Act
+            await converter.ConvertAsync(sourceStream, targetStream, ".txt", ".txt");
+
+            // Assert
+            targetStream.Position = 0;
+            var result = Encoding.UTF8.GetString(targetStream.ToArray());
+
+            Assert.Contains("HELLO WORLD!", result);
+            Assert.Contains("THIS IS A TEST.", result);
+        }
+
+        /// <summary>
+        /// <para>Tests text case conversion to lowercase.</para>
+        /// <para>Тестирует конверсию регистра текста в нижний.</para>
+        /// </summary>
+        [Fact]
+        public async Task TextToLowercaseConverter_ShouldConvertToLowercase()
+        {
+            // Arrange
+            var converter = new TextToLowercaseConverter();
+            var textContent = "HELLO WORLD!\nTHIS IS A TEST.";
+            var sourceStream = new MemoryStream(Encoding.UTF8.GetBytes(textContent));
+            var targetStream = new MemoryStream();
+
+            // Act
+            await converter.ConvertAsync(sourceStream, targetStream, ".txt", ".txt");
+
+            // Assert
+            targetStream.Position = 0;
+            var result = Encoding.UTF8.GetString(targetStream.ToArray());
+
+            Assert.Contains("hello world!", result);
+            Assert.Contains("this is a test.", result);
+        }
+
+        /// <summary>
+        /// <para>Tests converter capability checking.</para>
+        /// <para>Тестирует проверку возможностей конвертера.</para>
+        /// </summary>
+        [Fact]
+        public void Converters_CanConvert_ShouldReturnCorrectCapabilities()
+        {
+            // Arrange
+            var jsonToXml = new JsonToXmlConverter();
+            var xmlToJson = new XmlToJsonConverter();
+            var textToUpper = new TextToUppercaseConverter();
+
+            // Act & Assert
+            Assert.True(jsonToXml.CanConvert(".json", ".xml"));
+            Assert.False(jsonToXml.CanConvert(".xml", ".json"));
+            Assert.False(jsonToXml.CanConvert(".txt", ".xml"));
+
+            Assert.True(xmlToJson.CanConvert(".xml", ".json"));
+            Assert.False(xmlToJson.CanConvert(".json", ".xml"));
+            Assert.False(xmlToJson.CanConvert(".txt", ".json"));
+
+            Assert.True(textToUpper.CanConvert(".txt", ".txt"));
+            Assert.True(textToUpper.CanConvert(".text", ".txt"));
+            Assert.False(textToUpper.CanConvert(".json", ".txt"));
+        }
+
+        /// <summary>
+        /// <para>Tests that converters throw exceptions for unsupported conversions.</para>
+        /// <para>Тестирует что конвертеры выбрасывают исключения для неподдерживаемых конверсий.</para>
+        /// </summary>
+        [Fact]
+        public async Task Converters_UnsupportedConversion_ShouldThrowException()
+        {
+            // Arrange
+            var converter = new JsonToXmlConverter();
+            var sourceStream = new MemoryStream();
+            var targetStream = new MemoryStream();
+
+            // Act & Assert
+            await Assert.ThrowsAsync<NotSupportedException>(
+                () => converter.ConvertAsync(sourceStream, targetStream, ".xml", ".json"));
+        }
+    }
+}

csharp/Platform.Converters.CLI.Tests/Platform.Converters.CLI.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.6.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Platform.Converters.CLI/Platform.Converters.CLI.csproj" />
+    <ProjectReference Include="../Platform.Converters.Plugins.Examples/Platform.Converters.Plugins.Examples.csproj" />
+  </ItemGroup>
+
+</Project>

csharp/Platform.Converters.CLI.Tests/PluginLoaderTests.cs

@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using System.Linq;
+using Platform.Converters.CLI;
+using Platform.Converters.Plugins.Examples;
+using Xunit;
+
+namespace Platform.Converters.CLI.Tests
+{
+    /// <summary>
+    /// <para>Tests for the PluginLoader class.</para>
+    /// <para>Тесты для класса PluginLoader.</para>
+    /// </summary>
+    public class PluginLoaderTests
+    {
+        /// <summary>
+        /// <para>Tests that converters can be found by file extensions.</para>
+        /// <para>Тестирует что конвертеры могут быть найдены по расширениям файлов.</para>
+        /// </summary>
+        [Fact]
+        public void FindConverters_ShouldReturnCompatibleConverters()
+        {
+            // Arrange
+            var loader = new PluginLoader();
+            var jsonToXmlConverter = new JsonToXmlConverter();
+            var xmlToJsonConverter = new XmlToJsonConverter();
+            var textConverter = new TextToUppercaseConverter();
+
+            // Simulate loaded converters by using reflection to add them
+            var loadedConvertersField = typeof(PluginLoader)
+                .GetField("_loadedConverters", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+            var loadedConverters = (System.Collections.Generic.List<IFileConverter>)loadedConvertersField!.GetValue(loader)!;
+
+            loadedConverters.Add(jsonToXmlConverter);
+            loadedConverters.Add(xmlToJsonConverter);
+            loadedConverters.Add(textConverter);
+
+            // Act
+            var jsonToXmlConverters = loader.FindConverters(".json", ".xml");
+            var xmlToJsonConverters = loader.FindConverters(".xml", ".json");
+            var textConverters = loader.FindConverters(".txt", ".txt");
+            var noConverters = loader.FindConverters(".pdf", ".doc");
+
+            // Assert
+            Assert.Single(jsonToXmlConverters);
+            Assert.Contains(jsonToXmlConverter, jsonToXmlConverters);
+
+            Assert.Single(xmlToJsonConverters);
+            Assert.Contains(xmlToJsonConverter, xmlToJsonConverters);
+
+            Assert.Single(textConverters);
+            Assert.Contains(textConverter, textConverters);
+
+            Assert.Empty(noConverters);
+        }
+
+        /// <summary>
+        /// <para>Tests that plugin loading handles non-existent directories gracefully.</para>
+        /// <para>Тестирует что загрузка плагинов корректно обрабатывает несуществующие директории.</para>
+        /// </summary>
+        [Fact]
+        public void LoadPlugins_WithNonExistentDirectory_ShouldNotThrow()
+        {
+            // Arrange
+            var loader = new PluginLoader();
+            var nonExistentPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+
+            // Act & Assert
+            var exception = Record.Exception(() => loader.LoadPlugins(nonExistentPath));
+            Assert.Null(exception);
+        }
+
+        /// <summary>
+        /// <para>Tests that the loader starts with no converters loaded.</para>
+        /// <para>Тестирует что загрузчик начинает без загруженных конвертеров.</para>
+        /// </summary>
+        [Fact]
+        public void LoadedConverters_InitialState_ShouldBeEmpty()
+        {
+            // Arrange & Act
+            var loader = new PluginLoader();
+
+            // Assert
+            Assert.Empty(loader.LoadedConverters);
+        }
+    }
+}

csharp/Platform.Converters.CLI/Platform.Converters.CLI.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8</TargetFramework>
+    <AssemblyName>Platform.Converters.CLI</AssemblyName>
+    <PackageId>Platform.Converters.CLI</PackageId>
+    <Description>CLI tool for file conversion with plugin support</Description>
+    <Copyright>Konstantin Diachenko</Copyright>
+    <Authors>Konstantin Diachenko</Authors>
+    <VersionPrefix>0.1.0</VersionPrefix>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Platform.Converters/Platform.Converters.csproj" />
+  </ItemGroup>
+
+
+</Project>