Added saving code blocks of every programming language (#1117)

app/Tests/Settings/BatchProcessingResultFileFormatTests.cs

@@ -0,0 +1,107 @@
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+using AIStudio.Tools;
+
+using Lua;
+using Lua.Standard;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AIStudio.Tests.Settings;
+
+/// <summary>
+/// Checks which format of the result files an organization can preselect for the Batch Processing
+/// assistant through a configuration plugin.
+/// </summary>
+/// <remarks>
+/// The settings are reached through Program.SERVICE_PROVIDER, as in the app, because a managed setting
+/// writes its value and its lock there. The plugin passes the check of DataBatchProcessing, as
+/// PluginConfiguration does.
+/// </remarks>
+[TestFixture]
+public sealed class BatchProcessingResultFileFormatTests
+{
+    private static readonly Guid PLUGIN_ID = Guid.Parse("9d2f6c41-3b8e-4a07-b5d1-e6a8c2f04b73");
+
+    private SettingsManager settingsManager = null!;
+    private ServiceProvider serviceProvider = null!;
+    private IServiceProvider previousServiceProvider = null!;
+
+    [SetUp]
+    public void CreateSettings()
+    {
+        // Creating the settings data registers every managed setting:
+        this.settingsManager = new SettingsManager(NullLogger<SettingsManager>.Instance, null!);
+
+        this.previousServiceProvider = Program.SERVICE_PROVIDER;
+        this.serviceProvider = new ServiceCollection().AddSingleton(this.settingsManager).BuildServiceProvider();
+        Program.SERVICE_PROVIDER = this.serviceProvider;
+    }
+
+    [TearDown]
+    public void RestoreApplicationState()
+    {
+        // The managed state of a setting outlives this fixture, so we release what the plugin took over:
+        ManagedConfiguration.CleanupLeftOverManagedConfigurations([], new HashSet<Guid>());
+
+        Program.SERVICE_PROVIDER = this.previousServiceProvider;
+        this.serviceProvider.Dispose();
+    }
+
+    [Test]
+    public async Task APluginPreselectsAFormatForEntireAnswers()
+    {
+        var processed = await ProcessAsync("MICROSOFT_WORD");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(processed, Is.True);
+            Assert.That(this.ResultFileFormat, Is.EqualTo(FileExportFormat.MICROSOFT_WORD));
+        });
+    }
+
+    [TestCase("CSV", TestName = "A table, which holds one table out of an answer")]
+    [TestCase("SOURCE_CODE", TestName = "Code, which takes its extension from a language")]
+    [TestCase("NONE", TestName = "No format at all")]
+    public async Task AFormatWhichHoldsNoEntireAnswerIsRejected(string configuredFormat)
+    {
+        this.ResultFileFormat = FileExportFormat.HTML;
+        var processed = await ProcessAsync(configuredFormat);
+
+        ManagedConfiguration.TryGet(x => x.BatchProcessing, x => x.ResultFileFormat, out var configMeta);
+        Assert.Multiple(() =>
+        {
+            Assert.That(processed, Is.False, "The result files would end up without an extension or as something other than an answer.");
+            Assert.That(this.ResultFileFormat, Is.EqualTo(FileExportFormat.HTML), "A rejected value leaves the choice of the user untouched.");
+            Assert.That(configMeta.IsLocked, Is.False, "A rejected value locks nothing.");
+        });
+    }
+
+    private FileExportFormat ResultFileFormat
+    {
+        get => this.settingsManager.ConfigurationData.BatchProcessing.ResultFileFormat;
+        set => this.settingsManager.ConfigurationData.BatchProcessing.ResultFileFormat = value;
+    }
+
+    /// <summary>
+    /// Lets a configuration plugin preselect the format of the result files.
+    /// </summary>
+    /// <param name="format">The name of the format as the plugin writes it.</param>
+    /// <returns>Whether the plugin's value was taken.</returns>
+    private static async Task<bool> ProcessAsync(string format)
+    {
+        var state = LuaState.Create();
+        state.OpenBasicLibrary();
+
+        await state.DoStringAsync($"""
+                                   SETTINGS = {"{}"}
+                                   SETTINGS["DataBatchProcessing.ResultFileFormat"] = "{format}"
+                                   """);
+
+        if (!state.Environment["SETTINGS"].TryRead<LuaTable>(out var settingsTable))
+            throw new InvalidOperationException("The settings of this test are not a Lua table.");
+
+        return ManagedConfiguration.TryProcessConfiguration(x => x.BatchProcessing, x => x.ResultFileFormat, PLUGIN_ID, settingsTable, false, validator: DataBatchProcessing.IsValidResultFileFormat);
+    }
+}