Added the BeyondFacts Lab as a prototype (#1175)

2026-11-10 20:27:21 +00:00 · 2026-11-08 19:49:46 +01:00
1 parent db8dae1cf6
commit b6c3fbb5db
@@ -0,0 +1,469 @@
+using AIStudio.Assistants.BeyondFactsLab;
+
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks how the BeyondFacts Lab stores its preparations on disk.
+/// </summary>
+/// <remarks>
+/// People maintain the list of their preparations themselves: nothing gets deleted on its own, also not a
+/// preparation which this version cannot open.
+/// </remarks>
+[TestFixture]
+public sealed class BeyondFactsLabStoreTests
+{
+    private string dataDirectory = string.Empty;
+
+    private string RootDirectory => Path.Combine(this.dataDirectory, BeyondFactsLabStore.ROOT_DIRECTORY_NAME);
+
+    [SetUp]
+    public void CreateDataDirectory()
+    {
+        this.dataDirectory = Path.Combine(Path.GetTempPath(), $"ai-studio-beyondfacts-lab-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(this.dataDirectory);
+    }
+
+    [TearDown]
+    public void DeleteDataDirectory()
+    {
+        if (Directory.Exists(this.dataDirectory))
+            Directory.Delete(this.dataDirectory, true);
+    }
+
+    [Test]
+    public async Task ACreatedPreparationIsListedAndLoaded()
+    {
+        var store = this.CreateStore();
+
+        var created = await store.CreateAsync("  Panel on climate adaptation  ");
+        var projects = await store.ListProjectsAsync();
+        var loaded = await store.LoadAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(created.Name, Is.EqualTo("Panel on climate adaptation"));
+            Assert.That(created.SchemaVersion, Is.EqualTo(BflProject.CURRENT_SCHEMA_VERSION));
+            Assert.That(created.HappenedAtUtc, Is.Null);
+            Assert.That(projects, Has.Count.EqualTo(1));
+            Assert.That(projects[0].IsAvailable, Is.True);
+            Assert.That(projects[0].Name, Is.EqualTo(created.Name));
+            Assert.That(loaded, Is.Not.Null);
+            Assert.That(loaded!.Name, Is.EqualTo(created.Name));
+            Assert.That(loaded.CreatedAtUtc, Is.EqualTo(created.CreatedAtUtc));
+            Assert.That(File.Exists(this.ProjectPath(created.ProjectId)), Is.True);
+        }
+    }
+
+    [Test]
+    public async Task ANewStoreFindsThePreparationsOfTheLastOne()
+    {
+        var created = await this.CreateStore().CreateAsync("Interview");
+
+        var projects = await this.CreateStore().ListProjectsAsync();
+
+        Assert.That(projects.Select(project => project.ProjectId), Is.EqualTo(new[] { created.ProjectId }));
+    }
+
+    [Test]
+    public async Task ThePreparationChangedLastComesFirst()
+    {
+        var store = this.CreateStore();
+        var first = await store.CreateAsync("First");
+        var second = await store.CreateAsync("Second");
+
+        await store.RenameAsync(first.ProjectId, "First, renamed");
+        var projects = await store.ListProjectsAsync();
+
+        Assert.That(projects.Select(project => project.ProjectId), Is.EqualTo(new[] { first.ProjectId, second.ProjectId }));
+    }
+
+    [Test]
+    public async Task RenamingKeepsEverythingElse()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Old name");
+
+        var renamed = await store.RenameAsync(created.ProjectId, "New name");
+        var loaded = await store.LoadAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(renamed.Name, Is.EqualTo("New name"));
+            Assert.That(loaded!.Name, Is.EqualTo("New name"));
+            Assert.That(loaded.CreatedAtUtc, Is.EqualTo(created.CreatedAtUtc));
+            Assert.That(loaded.ModifiedAtUtc, Is.GreaterThanOrEqualTo(created.ModifiedAtUtc));
+        }
+    }
+
+    [TestCase("")]
+    [TestCase("   ")]
+    [TestCase("\a\t")]
+    public async Task AnEmptyNameIsRefused(string name)
+    {
+        var store = this.CreateStore();
+
+        await Assert.ThrowsAsync<ArgumentException>(async () => await store.CreateAsync(name));
+    }
+
+    [Test]
+    public async Task ANameLosesControlCharactersAndGetsCut()
+    {
+        var store = this.CreateStore();
+
+        var created = await store.CreateAsync("Talk\0 show" + new string('x', 300));
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(created.Name, Does.StartWith("Talk show"));
+            Assert.That(created.Name, Has.Length.EqualTo(BeyondFactsLabStore.MAX_NAME_LENGTH));
+        }
+    }
+
+    [Test]
+    public async Task TheEventCanBeMarkedAsHavingTakenPlaceAndBack()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        var happenedAt = new DateTimeOffset(2026, 12, 10, 14, 0, 0, TimeSpan.FromHours(1));
+
+        await store.SetHappenedAsync(created.ProjectId, happenedAt);
+        var afterMarking = await store.LoadAsync(created.ProjectId);
+        await store.SetHappenedAsync(created.ProjectId, null);
+        var afterTakingBack = await store.LoadAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(afterMarking!.HappenedAtUtc, Is.EqualTo(happenedAt));
+            Assert.That(afterMarking.HappenedAtUtc!.Value.Offset, Is.EqualTo(TimeSpan.Zero));
+            Assert.That(afterTakingBack!.HappenedAtUtc, Is.Null);
+        }
+    }
+
+    [Test]
+    public async Task DeletingRemovesTheFolderAndTheSelection()
+    {
+        var store = this.CreateStore();
+        var kept = await store.CreateAsync("Kept");
+        var deleted = await store.CreateAsync("Deleted");
+        await store.RememberSelectionAsync(deleted.ProjectId);
+
+        await store.DeleteAsync(deleted.ProjectId);
+        var projects = await store.ListProjectsAsync();
+        var newStore = this.CreateStore();
+        await newStore.ListProjectsAsync();
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(projects.Select(project => project.ProjectId), Is.EqualTo(new[] { kept.ProjectId }));
+            Assert.That(Directory.Exists(Path.Combine(this.RootDirectory, deleted.ProjectId.ToString("D"))), Is.False);
+            Assert.That(store.LastSelectedProjectId, Is.Null);
+            Assert.That(newStore.LastSelectedProjectId, Is.Null);
+        }
+    }
+
+    [Test]
+    public async Task TheSelectionSurvivesANewStore()
+    {
+        var store = this.CreateStore();
+        await store.CreateAsync("Other");
+        var selected = await store.CreateAsync("Selected");
+
+        await store.RememberSelectionAsync(selected.ProjectId);
+        var newStore = this.CreateStore();
+        await newStore.ListProjectsAsync();
+
+        Assert.That(newStore.LastSelectedProjectId, Is.EqualTo(selected.ProjectId));
+    }
+
+    [Test]
+    public async Task ASelectionOfAMissingPreparationIsDropped()
+    {
+        Directory.CreateDirectory(this.RootDirectory);
+        await File.WriteAllTextAsync(Path.Combine(this.RootDirectory, "selection.json"), $"\"{Guid.NewGuid():D}\"");
+
+        var store = this.CreateStore();
+        await store.ListProjectsAsync();
+
+        Assert.That(store.LastSelectedProjectId, Is.Null);
+    }
+
+    [Test]
+    public async Task NoTemporaryFileStaysBehind()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        await store.RenameAsync(created.ProjectId, "Panel, renamed");
+        await store.SetHappenedAsync(created.ProjectId, DateTimeOffset.UtcNow);
+        await store.RememberSelectionAsync(created.ProjectId);
+
+        Assert.That(Directory.EnumerateFiles(this.RootDirectory, "*.tmp-*", SearchOption.AllDirectories), Is.Empty);
+    }
+
+    [Test]
+    public async Task ANewStoreRemovesTemporaryFilesACrashLeftBehind()
+    {
+        var created = await this.CreateStore().CreateAsync("Panel");
+        var leftOver = $"{this.ProjectPath(created.ProjectId)}.tmp-{Guid.NewGuid():N}";
+        await File.WriteAllTextAsync(leftOver, "{");
+
+        await this.CreateStore().ListProjectsAsync();
+
+        Assert.That(File.Exists(leftOver), Is.False);
+    }
+
+    [Test]
+    public async Task ADamagedPreparationIsListedButNeitherOpenedNorChangedNorDeleted()
+    {
+        const string DAMAGED = "{ \"name\": \"Damaged panel\", \"projectId\": ";
+        var projectId = Guid.NewGuid();
+        var path = await this.WriteProjectFileAsync(projectId, DAMAGED);
+        var store = this.CreateStore();
+
+        var projects = await store.ListProjectsAsync();
+        var loaded = await store.LoadAsync(projectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(projects, Has.Count.EqualTo(1));
+            Assert.That(projects[0].ProjectId, Is.EqualTo(projectId));
+            Assert.That(projects[0].Status, Is.EqualTo(BflProjectLoadStatus.UNAVAILABLE));
+            Assert.That(projects[0].IsAvailable, Is.False);
+            Assert.That(loaded, Is.Null);
+            await Assert.ThrowsAsync<InvalidDataException>(async () => await store.RenameAsync(projectId, "Repaired"));
+            Assert.That(await File.ReadAllTextAsync(path), Is.EqualTo(DAMAGED));
+        }
+    }
+
+    [Test]
+    public async Task APreparationOfANewerVersionIsListedWithItsNameAndNotWritten()
+    {
+        var projectId = Guid.NewGuid();
+        var json = $$"""
+                     {
+                       "schemaVersion": {{BflProject.CURRENT_SCHEMA_VERSION + 1}},
+                       "projectId": "{{projectId:D}}",
+                       "name": "Panel of the future",
+                       "createdAtUtc": "2026-11-01T10:00:00+00:00",
+                       "modifiedAtUtc": "2026-11-02T10:00:00+00:00",
+                       "fieldOfANewerVersion": true
+                     }
+                     """;
+
+        var path = await this.WriteProjectFileAsync(projectId, json);
+        var store = this.CreateStore();
+
+        var projects = await store.ListProjectsAsync();
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(projects[0].Status, Is.EqualTo(BflProjectLoadStatus.NEWER_VERSION));
+            Assert.That(projects[0].Name, Is.EqualTo("Panel of the future"));
+            Assert.That(projects[0].ModifiedAtUtc, Is.EqualTo(new DateTimeOffset(2026, 11, 2, 10, 0, 0, TimeSpan.Zero)));
+            await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SetHappenedAsync(projectId, DateTimeOffset.UtcNow));
+            Assert.That(await File.ReadAllTextAsync(path), Is.EqualTo(json));
+        }
+    }
+
+    [Test]
+    public async Task APreparationWhoseFileNamesAnotherIdIsNotOpened()
+    {
+        var projectId = Guid.NewGuid();
+        await this.WriteProjectFileAsync(projectId, $$"""{ "schemaVersion": 1, "projectId": "{{Guid.NewGuid():D}}", "name": "Moved" }""");
+        var store = this.CreateStore();
+
+        var projects = await store.ListProjectsAsync();
+        var loaded = await store.LoadAsync(projectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(projects[0].Status, Is.EqualTo(BflProjectLoadStatus.UNAVAILABLE));
+            Assert.That(projects[0].Name, Is.EqualTo("Moved"));
+            Assert.That(loaded, Is.Null);
+        }
+    }
+
+    [Test]
+    public async Task APreparationWhichCannotBeOpenedCanStillBeDeleted()
+    {
+        var projectId = Guid.NewGuid();
+        await this.WriteProjectFileAsync(projectId, "not JSON at all");
+        var store = this.CreateStore();
+
+        await store.DeleteAsync(projectId);
+
+        Assert.That(await store.ListProjectsAsync(), Is.Empty);
+    }
+
+    [Test]
+    public async Task FoldersWhichAreNoPreparationsAreIgnored()
+    {
+        Directory.CreateDirectory(Path.Combine(this.RootDirectory, "promptOverrides"));
+        var created = await this.CreateStore().CreateAsync("Panel");
+
+        var projects = await this.CreateStore().ListProjectsAsync();
+
+        Assert.That(projects.Select(project => project.ProjectId), Is.EqualTo(new[] { created.ProjectId }));
+    }
+
+    [Test]
+    public async Task UmlautsStayReadableInTheFile()
+    {
+        var created = await this.CreateStore().CreateAsync("Podiumsdiskussion über Gewässerschutz");
+
+        var json = await File.ReadAllTextAsync(this.ProjectPath(created.ProjectId));
+
+        Assert.That(json, Does.Contain("Podiumsdiskussion über Gewässerschutz"));
+    }
+
+    [Test]
+    public async Task AFormIsStoredInTheFolderOfItsStepAndCountsAsAChange()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        var form = new BflStepFormData();
+        form.Set(BflFieldCatalog.FORMAT, "Panel discussion");
+
+        var changed = await store.SaveFormAsync(created.ProjectId, BflStep.FRAMEWORK, form);
+        var loaded = await this.CreateStore().LoadFormAsync(created.ProjectId, BflStep.FRAMEWORK);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(File.Exists(Path.Combine(this.RootDirectory, created.ProjectId.ToString("D"), "steps", "01-framework", "form.json")), Is.True);
+            Assert.That(loaded.Get(BflFieldCatalog.FORMAT), Is.EqualTo("Panel discussion"));
+            Assert.That(changed.ModifiedAtUtc, Is.GreaterThan(created.ModifiedAtUtc));
+            Assert.That((await store.LoadAsync(created.ProjectId))!.ModifiedAtUtc, Is.EqualTo(changed.ModifiedAtUtc));
+        }
+    }
+
+    [Test]
+    public async Task AStepWithoutAFormGetsAnEmptyOne()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+
+        var form = await store.LoadFormAsync(created.ProjectId, BflStep.STRATEGY);
+        var forms = await store.LoadFormsAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(form.Values, Is.Empty);
+            Assert.That(forms.Keys, Is.EquivalentTo(BflStep.All));
+        }
+    }
+
+    [Test]
+    public async Task AValueOfAFieldThisVersionDoesNotKnowIsKept()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        var formPath = await this.WriteFormFileAsync(created.ProjectId, "02-knowledge", """{ "schemaVersion": 1, "values": { "field_of_a_newer_version": "kept" } }""");
+
+        var form = await store.LoadFormAsync(created.ProjectId, BflStep.KNOWLEDGE);
+        form.Set(BflFieldCatalog.CORE_THESES, "Thesis");
+        await store.SaveFormAsync(created.ProjectId, BflStep.KNOWLEDGE, form);
+
+        var json = await File.ReadAllTextAsync(formPath);
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(json, Does.Contain("field_of_a_newer_version"));
+            Assert.That(json, Does.Contain("Thesis"));
+        }
+    }
+
+    [Test]
+    public async Task ADamagedFormIsNeitherOpenedNorOverwritten()
+    {
+        const string DAMAGED = "{ \"values\": ";
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        var formPath = await this.WriteFormFileAsync(created.ProjectId, "01-framework", DAMAGED);
+
+        var forms = await store.LoadFormsAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(forms.ContainsKey(BflStep.FRAMEWORK), Is.False);
+            Assert.That(forms.ContainsKey(BflStep.KNOWLEDGE), Is.True);
+            await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadFormAsync(created.ProjectId, BflStep.FRAMEWORK));
+            await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SaveFormAsync(created.ProjectId, BflStep.FRAMEWORK, new BflStepFormData()));
+            Assert.That(await File.ReadAllTextAsync(formPath), Is.EqualTo(DAMAGED));
+        }
+    }
+
+    [Test]
+    public async Task AFormOfANewerVersionIsNotOverwritten()
+    {
+        const string NEWER = """{ "schemaVersion": 2, "values": {} }""";
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+        var formPath = await this.WriteFormFileAsync(created.ProjectId, "05-strategy", NEWER);
+
+        using (Assert.EnterMultipleScope())
+        {
+            await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SaveFormAsync(created.ProjectId, BflStep.STRATEGY, new BflStepFormData()));
+            Assert.That(await File.ReadAllTextAsync(formPath), Is.EqualTo(NEWER));
+        }
+    }
+
+    [Test]
+    public async Task AFormOfAPreparationWhichCannotBeOpenedIsNotWritten()
+    {
+        var projectId = Guid.NewGuid();
+        await this.WriteProjectFileAsync(projectId, "not JSON at all");
+        var store = this.CreateStore();
+
+        await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SaveFormAsync(projectId, BflStep.FRAMEWORK, new BflStepFormData()));
+
+        Assert.That(Directory.Exists(Path.Combine(this.RootDirectory, projectId.ToString("D"), "steps")), Is.False);
+    }
+
+    [Test]
+    public async Task TheStepShownLastIsRememberedWithoutCountingAsAChange()
+    {
+        var store = this.CreateStore();
+        var created = await store.CreateAsync("Panel");
+
+        await store.SetCurrentStepAsync(created.ProjectId, BflStep.STRATEGY);
+        var loaded = await this.CreateStore().LoadAsync(created.ProjectId);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(created.CurrentStep, Is.EqualTo(BflStep.FRAMEWORK));
+            Assert.That(loaded!.CurrentStep, Is.EqualTo(BflStep.STRATEGY));
+            Assert.That(loaded.ModifiedAtUtc, Is.EqualTo(created.ModifiedAtUtc));
+        }
+    }
+
+    [Test]
+    public async Task APreparationWithAnUnknownStepIsNotOpened()
+    {
+        var projectId = Guid.NewGuid();
+        await this.WriteProjectFileAsync(projectId, $$"""{ "schemaVersion": 1, "projectId": "{{projectId:D}}", "name": "Panel", "currentStep": 42 }""");
+
+        var loaded = await this.CreateStore().LoadAsync(projectId);
+
+        Assert.That(loaded, Is.Null);
+    }
+
+    private BeyondFactsLabStore CreateStore() => new(NullLogger<BeyondFactsLabStore>.Instance, new BflStorageOptions { DataDirectory = this.dataDirectory });
+
+    private async Task<string> WriteFormFileAsync(Guid projectId, string stepFolder, string content)
+    {
+        var path = Path.Combine(this.RootDirectory, projectId.ToString("D"), "steps", stepFolder, "form.json");
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        await File.WriteAllTextAsync(path, content);
+        return path;
+    }
+
+    private string ProjectPath(Guid projectId) => Path.Combine(this.RootDirectory, projectId.ToString("D"), "project.json");
+
+    private async Task<string> WriteProjectFileAsync(Guid projectId, string content)
+    {
+        var path = this.ProjectPath(projectId);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        await File.WriteAllTextAsync(path, content);
+        return path;
+    }
+}
@@ -0,0 +1,73 @@
+using AIStudio.Assistants.BeyondFactsLab;
+using AIStudio.Provider;
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks who may open the page of the BeyondFacts Lab and what its settings offer.
+/// </summary>
+/// <remarks>
+/// The page asks by itself whether it may be opened, because its address can be reached without the tile.
+/// </remarks>
+[TestFixture]
+public sealed class BflAccessTests
+{
+    [Test]
+    public void ThePageStaysClosedWithoutThePreviewFeature()
+    {
+        Assert.That(BflAccess.CanOpen(CreateSettingsManager()), Is.False);
+    }
+
+    [Test]
+    public void ThePageOpensWithThePreviewFeature()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.App.EnabledPreviewFeatures.Add(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026);
+
+        Assert.That(BflAccess.CanOpen(settingsManager), Is.True);
+    }
+
+    [Test]
+    public void ThePageStaysClosedWhenAnOrganizationHidesTheLab()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.App.EnabledPreviewFeatures.Add(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026);
+        settingsManager.ConfigurationData.App.HiddenAssistants.Add(ConfigurableAssistant.BEYOND_FACTS_LAB_ASSISTANT);
+
+        Assert.That(BflAccess.CanOpen(settingsManager), Is.False);
+    }
+
+    [Test]
+    public void TheSettingsOfferNoConfidenceBelowMedium()
+    {
+        var levels = ConfigurationSelectDataFactory.GetBeyondFactsLabConfidenceLevelsData(CreateSettingsManager()).Select(data => data.Value);
+
+        Assert.That(levels, Is.EqualTo(new[] { ConfidenceLevel.MEDIUM, ConfidenceLevel.HIGH }));
+    }
+
+    [Test]
+    public void AnEnforcedGlobalMinimumLiftsTheChoice()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.Confidence.EnforceGlobalMinimumConfidence = true;
+        settingsManager.ConfigurationData.Confidence.GlobalMinimumConfidence = ConfidenceLevel.HIGH;
+
+        var levels = ConfigurationSelectDataFactory.GetBeyondFactsLabConfidenceLevelsData(settingsManager).Select(data => data.Value);
+
+        Assert.That(levels, Is.EqualTo(new[] { ConfidenceLevel.HIGH }));
+    }
+
+    [Test]
+    public void TheSettingsOfferEveryFormOfAddress()
+    {
+        var forms = ConfigurationSelectDataFactory.GetBeyondFactsLabAddressFormData().Select(data => data.Value);
+
+        Assert.That(forms, Is.EquivalentTo(Enum.GetValues<BflAddressForm>()));
+    }
+
+    private static SettingsManager CreateSettingsManager() => new(NullLogger<SettingsManager>.Instance, null!);
+}
@@ -0,0 +1,151 @@
+using AIStudio.Assistants.BeyondFactsLab;
+using AIStudio.Provider;
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+using AIStudio.Tools;
+
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks how the BeyondFacts Lab is registered as a component: who may see it, which providers it accepts,
+/// and what it shares with the rest of the app.
+/// </summary>
+/// <remarks>
+/// The component is written out in full, AIStudio.Tools.Components: from this namespace, the short name finds
+/// the test namespace AIStudio.Tests.Components first.
+/// </remarks>
+[TestFixture]
+public sealed class BflComponentTests
+{
+    private const AIStudio.Tools.Components LAB = AIStudio.Tools.Components.BEYOND_FACTS_LAB_ASSISTANT;
+
+    [Test]
+    public void TheLabBelongsToItsPreviewFeature()
+    {
+        Assert.That(LAB.RequiredPreviewFeature, Is.EqualTo(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026), "The tile, the page, and the menus all ask the component for its preview feature.");
+    }
+
+    [Test]
+    public void TheLabIsHiddenWithoutItsPreviewFeature()
+    {
+        var settingsManager = CreateSettingsManager();
+
+        Assert.That(settingsManager.IsAssistantVisible(LAB, requiredPreviewFeature: LAB.RequiredPreviewFeature), Is.False);
+    }
+
+    [Test]
+    public void TheLabIsVisibleWithItsPreviewFeature()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.App.EnabledPreviewFeatures.Add(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026);
+
+        Assert.That(settingsManager.IsAssistantVisible(LAB, requiredPreviewFeature: LAB.RequiredPreviewFeature), Is.True);
+    }
+
+    [Test]
+    public void AnOrganizationCanHideTheLab()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.App.EnabledPreviewFeatures.Add(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026);
+        settingsManager.ConfigurationData.App.HiddenAssistants.Add(ConfigurableAssistant.BEYOND_FACTS_LAB_ASSISTANT);
+
+        Assert.That(settingsManager.IsAssistantVisible(LAB, requiredPreviewFeature: LAB.RequiredPreviewFeature), Is.False, "The list of hidden assistants must reach the lab, too.");
+    }
+
+    [TestCase(ConfidenceLevel.NONE)]
+    [TestCase(ConfidenceLevel.LOW)]
+    [TestCase(ConfidenceLevel.MODERATE)]
+    [TestCase(ConfidenceLevel.MEDIUM)]
+    public void TheMinimumConfidenceNeverDropsBelowMedium(ConfidenceLevel configured)
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.BeyondFactsLab.MinimumProviderConfidence = configured;
+
+        Assert.That(LAB.MinimumConfidence(settingsManager), Is.EqualTo(ConfidenceLevel.MEDIUM));
+    }
+
+    [Test]
+    public void AHigherMinimumConfidenceWins()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.BeyondFactsLab.MinimumProviderConfidence = ConfidenceLevel.HIGH;
+
+        Assert.That(LAB.MinimumConfidence(settingsManager), Is.EqualTo(ConfidenceLevel.HIGH));
+    }
+
+    /// <summary>
+    /// Checks that the lab takes the cloud providers of the region one trusts and refuses all others.
+    /// </summary>
+    /// <remarks>
+    /// The scheme which trusts Europe gives MEDIUM to Mistral and LOW to OpenAI. MEDIUM is the floor of the
+    /// lab, so only the first one may see unpublished research.
+    /// </remarks>
+    [Test]
+    public void OnlyProvidersOfTheTrustedRegionAreAccepted()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.Confidence.ConfidenceScheme = ConfidenceSchemes.TRUST_EUROPE;
+        var trusted = CreateProvider(LLMProviders.MISTRAL);
+        var untrusted = CreateProvider(LLMProviders.OPEN_AI);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(settingsManager.IsProviderConfident(trusted, LAB), Is.True);
+            Assert.That(settingsManager.IsProviderConfident(untrusted, LAB), Is.False);
+        }
+    }
+
+    [Test]
+    public void AProhibitedProviderIsRefusedAlthoughTrusted()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.Confidence.ConfidenceScheme = ConfidenceSchemes.TRUST_EUROPE;
+        settingsManager.ConfigurationData.App.ProhibitedProviders.Add(LLMProviders.MISTRAL);
+
+        Assert.That(settingsManager.IsProviderConfident(CreateProvider(LLMProviders.MISTRAL), LAB), Is.False);
+    }
+
+    [Test]
+    public void TheLabNeitherSendsNorReceivesContent()
+    {
+        Assert.That(LAB.AllowSendTo, Is.False, "Nothing may enter the lab from other places, and its answers stay in its steps.");
+    }
+
+    [Test]
+    public void TheLabKeepsOneSessionPerStep()
+    {
+        Assert.That(LAB.HasSingleSessionSlot, Is.False, "A running step must not block the steps of other preparations.");
+    }
+
+    [Test]
+    public void TheLabWorksWithoutAProfile()
+    {
+        var settingsManager = CreateSettingsManager();
+        settingsManager.ConfigurationData.App.PreselectedProfile = Guid.NewGuid().ToString();
+
+        Assert.That(LAB.GetProfilePreselection(settingsManager), Is.EqualTo(ProfilePreselection.FromStoredValue(Profile.NO_PROFILE.Id)), "The lab works with what the person enters per preparation, never with the app-wide profile.");
+    }
+
+    [Test]
+    public void TheLabStartsWithItsPreselectedProvider()
+    {
+        var settingsManager = CreateSettingsManager();
+        var provider = CreateProvider(LLMProviders.MISTRAL);
+        settingsManager.ConfigurationData.Providers.Add(provider);
+        settingsManager.ConfigurationData.BeyondFactsLab.PreselectedProvider = provider.Id;
+
+        Assert.That(LAB.PreselectedProvider(settingsManager).Id, Is.EqualTo(provider.Id));
+    }
+
+    [Test]
+    public void NewSettingsAddressFormally()
+    {
+        Assert.That(new DataBeyondFactsLab().AddressForm, Is.EqualTo(BflAddressForm.FORMAL), "The texts of AI Studio address the person formally as well.");
+    }
+
+    private static SettingsManager CreateSettingsManager() => new(NullLogger<SettingsManager>.Instance, null!);
+
+    private static AIStudio.Settings.Provider CreateProvider(LLMProviders llmProvider) => new(1, Guid.NewGuid().ToString(), "Test", llmProvider, new("test-model", null));
+}
@@ -0,0 +1,170 @@
+using AIStudio.Assistants.BeyondFactsLab;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks the steps and the fields of the forms "Your details" in the BeyondFacts Lab.
+/// </summary>
+/// <remarks>
+/// The forms store their values under the IDs of the fields and options, and the folders of the steps carry their
+/// names, so all of them are pinned here: changing one would lose what people entered before.
+/// </remarks>
+[TestFixture]
+public sealed class BflFieldCatalogTests
+{
+    [Test]
+    public void TheStepsKeepTheirNamesAndOrder()
+    {
+        Assert.That(BflStep.All.Select(step => step.ToString()), Is.EqualTo(new[]
+        {
+            "FRAMEWORK", "KNOWLEDGE", "GOALS_AND_ROLE", "VALUES_AND_PERSPECTIVES", "STRATEGY", "TEST_SITUATION", "RESULTS",
+        }));
+    }
+
+    [Test]
+    public void TheFoldersOfTheStepsKeepTheirNames()
+    {
+        Assert.That(BflStep.All.Select(step => step.FolderName), Is.EqualTo(new[]
+        {
+            "01-framework", "02-knowledge", "03-goals", "04-values", "05-strategy", "06-test", "07-results",
+        }));
+    }
+
+    [Test]
+    public void TheFieldsKeepTheirIds()
+    {
+        Assert.That(BflFieldCatalog.FIELDS.Select(field => field.Id), Is.EqualTo(new[]
+        {
+            "format", "event_topic", "audience", "contribution_topic", "event_date", "event_location", "event_duration", "contribution_duration", "other_participants", "event_link",
+            "contribution_summary", "core_theses", "uncertainties", "material_notes",
+            "goals", "goal_directions",
+            "values_and_concerns", "personal_concern", "other_perspectives",
+            "communication_worries",
+            "question_type", "difficulty", "test_notes",
+            "position_changes",
+        }));
+    }
+
+    [Test]
+    public void TheOptionsKeepTheirIds()
+    {
+        Assert.That(BflFieldCatalog.FIELDS.SelectMany(field => field.Options).Select(option => option.Id), Is.EqualTo(new[]
+        {
+            "goal_inform", "goal_moderate", "goal_take_position", "goal_raise_awareness", "goal_show_options", "goal_influence_policy",
+            "questions_mixed", "questions_scientific_criticism", "questions_emotional_criticism", "questions_manipulative", "questions_political_instrumentalization",
+            "difficulty_moderate", "difficulty_demanding", "difficulty_very_demanding",
+        }));
+    }
+
+    [Test]
+    public void EveryIdIsUnique()
+    {
+        var ids = BflFieldCatalog.FIELDS.Select(field => field.Id).Concat(BflFieldCatalog.FIELDS.SelectMany(field => field.Options).Select(option => option.Id)).ToList();
+
+        Assert.That(ids, Is.Unique);
+    }
+
+    [Test]
+    public void TheFieldsOfAStepFollowEachOther()
+    {
+        var stepsInOrder = BflFieldCatalog.FIELDS.Select(field => field.Step).Distinct();
+
+        Assert.That(stepsInOrder, Is.EqualTo(BflStep.All));
+    }
+
+    [Test]
+    public void EveryStepHasAFormWithATitleAndADescription()
+    {
+        using (Assert.EnterMultipleScope())
+        {
+            foreach (var step in BflStep.All)
+            {
+                Assert.That(BflFieldCatalog.ForStep(step), Is.Not.Empty, $"{step} has no fields.");
+                Assert.That(step.Title, Is.Not.Empty, $"{step} has no title.");
+                Assert.That(step.Description, Is.Not.Empty, $"{step} has no description.");
+            }
+        }
+    }
+
+    [Test]
+    public void OnlyFieldsWithAChoiceHaveOptions()
+    {
+        using (Assert.EnterMultipleScope())
+        {
+            foreach (var field in BflFieldCatalog.FIELDS)
+            {
+                if (field.Kind.HasOptions)
+                    Assert.That(field.Options, Has.Count.GreaterThanOrEqualTo(2), $"{field.Id} offers too few options.");
+                else
+                    Assert.That(field.Options, Is.Empty, $"{field.Id} has options, but nothing shows them.");
+            }
+        }
+    }
+
+    [Test]
+    public void EveryKindHasALimit()
+    {
+        Assert.That(Enum.GetValues<BflFieldKind>().Select(kind => kind.MaxLength), Has.All.GreaterThan(0));
+    }
+
+    [Test]
+    public void EveryFieldAndOptionHasALabel()
+    {
+        using (Assert.EnterMultipleScope())
+        {
+            foreach (var field in BflFieldCatalog.FIELDS)
+            {
+                Assert.That(field.Label, Is.Not.Empty, $"{field.Id} has no label.");
+                foreach (var option in field.Options)
+                    Assert.That(option.Label, Is.Not.Empty, $"{option.Id} has no label.");
+            }
+        }
+    }
+
+    [Test]
+    public void EveryFieldAndOptionHasALabelOfItsOwn()
+    {
+        // Equal English texts share one key of the localization, so another language could not tell them apart:
+        var labels = BflFieldCatalog.FIELDS.SelectMany(field => field.Options.Select(option => option.Label).Prepend(field.Label));
+
+        Assert.That(labels, Is.Unique);
+    }
+
+    [Test]
+    public void OnlyPublicDetailsAboutTheEventReachTheResearch()
+    {
+        var shared = BflFieldCatalog.FIELDS.Where(field => field.IsSharedWithResearch).Select(field => field.Id);
+
+        Assert.That(shared, Is.EquivalentTo(new[]
+        {
+            BflFieldCatalog.FORMAT, BflFieldCatalog.EVENT_TOPIC, BflFieldCatalog.EVENT_DATE, BflFieldCatalog.EVENT_LOCATION, BflFieldCatalog.OTHER_PARTICIPANTS, BflFieldCatalog.EVENT_LINK,
+        }), "The topic of a contribution may be unpublished, and nothing personal belongs on the web.");
+    }
+
+    [Test]
+    public void OnlyThePersonalInvolvementIsPersonal()
+    {
+        var personal = BflFieldCatalog.FIELDS.Where(field => field.IsPersonalDisclosure).Select(field => field.Id);
+
+        Assert.That(personal, Is.EquivalentTo(new[] { BflFieldCatalog.PERSONAL_CONCERN }));
+    }
+
+    [Test]
+    public void OnlyTheOtherParticipantsHoldNames()
+    {
+        var withNames = BflFieldCatalog.FIELDS.Where(field => field.NameRole is not BflNameRole.NONE).Select(field => field.Id);
+
+        Assert.That(withNames, Is.EquivalentTo(new[] { BflFieldCatalog.OTHER_PARTICIPANTS }));
+    }
+
+    [Test]
+    public void TheKeyDetailsAreThoseOfTheEventAndTheContribution()
+    {
+        var keyDetails = BflFieldCatalog.FIELDS.Where(field => field.IsKeyDetail).Select(field => field.Id);
+
+        Assert.That(keyDetails, Is.EquivalentTo(new[]
+        {
+            BflFieldCatalog.FORMAT, BflFieldCatalog.EVENT_TOPIC, BflFieldCatalog.AUDIENCE, BflFieldCatalog.CONTRIBUTION_TOPIC, BflFieldCatalog.CONTRIBUTION_SUMMARY,
+        }));
+    }
+}
@@ -0,0 +1,94 @@
+using AIStudio.Assistants.BeyondFactsLab;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks which details of a preparation the BeyondFacts Lab marks as missing, and how a form keeps its values.
+/// </summary>
+[TestFixture]
+public sealed class BflMissingDetailsTests
+{
+    [Test]
+    public void ANewPreparationLacksTheDetailsOfTheEventAndTheContribution()
+    {
+        var steps = BflMissingDetails.StepsOf(new Dictionary<BflStep, BflStepFormData>());
+
+        Assert.That(steps, Is.EqualTo(new[] { BflStep.FRAMEWORK, BflStep.KNOWLEDGE }));
+    }
+
+    [Test]
+    public void TheMissingDetailsFollowTheOrderOfTheForm()
+    {
+        var form = new BflStepFormData();
+        form.Set(BflFieldCatalog.EVENT_TOPIC, "Water protection");
+
+        var missing = BflMissingDetails.Of(BflStep.FRAMEWORK, form);
+
+        Assert.That(missing.Select(field => field.Id), Is.EqualTo(new[] { BflFieldCatalog.FORMAT, BflFieldCatalog.AUDIENCE, BflFieldCatalog.CONTRIBUTION_TOPIC }));
+    }
+
+    [Test]
+    public void BlanksCountAsMissing()
+    {
+        var form = new BflStepFormData { Values = { [BflFieldCatalog.CONTRIBUTION_SUMMARY] = "  \n " } };
+
+        Assert.That(BflMissingDetails.Of(BflStep.KNOWLEDGE, form), Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public void AFilledFormLacksNothing()
+    {
+        var framework = new BflStepFormData();
+        foreach (var field in BflFieldCatalog.ForStep(BflStep.FRAMEWORK))
+            framework.Set(field.Id, "given");
+
+        var knowledge = new BflStepFormData();
+        knowledge.Set(BflFieldCatalog.CONTRIBUTION_SUMMARY, "A few sentences.");
+
+        var steps = BflMissingDetails.StepsOf(new Dictionary<BflStep, BflStepFormData> { [BflStep.FRAMEWORK] = framework, [BflStep.KNOWLEDGE] = knowledge });
+
+        Assert.That(steps, Is.Empty);
+    }
+
+    [Test]
+    public void AnEmptyValueRemovesTheField()
+    {
+        var form = new BflStepFormData();
+        form.Set(BflFieldCatalog.GOALS, "Inform the audience");
+
+        form.Set(BflFieldCatalog.GOALS, " ");
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(form.Values, Is.Empty);
+            Assert.That(form.Get(BflFieldCatalog.GOALS), Is.Empty);
+        }
+    }
+
+    [Test]
+    public void ChoicesAreStoredInTheOrderOfTheOptions()
+    {
+        var field = BflFieldCatalog.FIELDS.Single(candidate => candidate.Id == BflFieldCatalog.GOAL_DIRECTIONS);
+        var form = new BflStepFormData();
+
+        form.SetChoices(field, [BflFieldCatalog.GOAL_INFLUENCE_POLICY, BflFieldCatalog.GOAL_INFORM, "not_an_option"]);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(form.Get(field.Id), Is.EqualTo($"{BflFieldCatalog.GOAL_INFORM},{BflFieldCatalog.GOAL_INFLUENCE_POLICY}"));
+            Assert.That(form.GetChoices(field.Id), Is.EquivalentTo(new[] { BflFieldCatalog.GOAL_INFORM, BflFieldCatalog.GOAL_INFLUENCE_POLICY }));
+        }
+    }
+
+    [Test]
+    public void NoChoiceRemovesTheField()
+    {
+        var field = BflFieldCatalog.FIELDS.Single(candidate => candidate.Id == BflFieldCatalog.GOAL_DIRECTIONS);
+        var form = new BflStepFormData();
+        form.SetChoices(field, [BflFieldCatalog.GOAL_INFORM]);
+
+        form.SetChoices(field, []);
+
+        Assert.That(form.Values, Is.Empty);
+    }
+}
@@ -0,0 +1,81 @@
+using System.Runtime.CompilerServices;
+
+using AIStudio.Assistants.BeyondFactsLab;
+
+using SharedTools;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks the notes the BeyondFacts Lab shows before the first use, and when they show again.
+/// </summary>
+[TestFixture]
+public sealed class BflNoticeTests
+{
+    [Test]
+    public void TheNotesAreMarkdownWithAHeadingAndParagraphs()
+    {
+        var paragraphs = BflNotice.Text.ReplaceLineEndings("\n").Split("\n\n");
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(paragraphs[0], Is.EqualTo("## Welcome!"));
+            Assert.That(paragraphs, Has.Length.EqualTo(5));
+            Assert.That(paragraphs[^1], Does.Contain("prototype"));
+            Assert.That(paragraphs, Has.None.StartsWith(" "), "The indentation of the source must not reach the notes.");
+        }
+    }
+
+    [Test]
+    public void TheCollectorFindsTheNotesAsTheAppShowsThem()
+    {
+        var source = File.ReadAllText(NoticeSourceFile());
+        var warnings = new List<string>();
+
+        var texts = I18NSourceScanner.FindTexts(source, NoticeSourceFile(), warnings).Select(text => I18NKeyHash.NormalizeLineEndings(text.Text));
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(texts, Does.Contain(I18NKeyHash.NormalizeLineEndings(BflNotice.Text)));
+            Assert.That(warnings, Is.Empty);
+        }
+    }
+
+    [Test]
+    public void AChangeOfTheNotesChangesTheHash()
+    {
+        var hash = BflNotice.ComputeHash("## Welcome!\n\nThe notes.");
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(BflNotice.ComputeHash("## Welcome!\n\nThe changed notes."), Is.Not.EqualTo(hash));
+            Assert.That(BflNotice.ComputeHash("## Herzlich willkommen!\n\nDie Hinweise."), Is.Not.EqualTo(hash), "Notes in another language were not read yet.");
+        }
+    }
+
+    [Test]
+    public void LineEndingsAndOuterSpaceDoNotChangeTheHash()
+    {
+        var hash = BflNotice.ComputeHash("First line\n\nSecond line");
+
+        Assert.That(BflNotice.ComputeHash("  First line\r\n\r\nSecond line\r\n"), Is.EqualTo(hash));
+    }
+
+    [Test]
+    public void OnlyTheHashOfTheNotesAsTheyAreNowCountsAsConfirmed()
+    {
+        var currentHash = BflNotice.ComputeHash(BflNotice.Text);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(currentHash, Has.Length.EqualTo(64));
+            Assert.That(BflNotice.IsAccepted(currentHash, currentHash), Is.True);
+            Assert.That(BflNotice.IsAccepted(currentHash.ToUpperInvariant(), currentHash), Is.True);
+            Assert.That(BflNotice.IsAccepted(string.Empty, currentHash), Is.False, "Nobody confirmed anything yet.");
+            Assert.That(BflNotice.IsAccepted(BflNotice.ComputeHash("old"), currentHash), Is.False, "The notes changed since.");
+        }
+    }
+
+    private static string NoticeSourceFile([CallerFilePath] string sourceFilePath = "") =>
+        Path.GetFullPath(Path.Combine(Path.GetDirectoryName(sourceFilePath)!, "..", "..", "MindWork AI Studio", "Assistants", "BeyondFactsLab", "BflNotice.cs"));
+}
@@ -0,0 +1,68 @@
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks that the BeyondFacts Lab stays a prototype which nobody sees unless they ask for it.
+/// </summary>
+/// <remarks>
+/// The lab grows over a long series of pull requests. Until it is complete, only people who allow
+/// prototypes and switch the lab on may find it; raising its level is a decision of its own.
+/// </remarks>
+[TestFixture]
+public sealed class BflPreviewFeatureTests
+{
+    [TestCase(PreviewVisibility.PROTOTYPE)]
+    [TestCase(PreviewVisibility.EXPERIMENTAL)]
+    public void PrototypesOfferTheLab(PreviewVisibility visibility)
+    {
+        Assert.That(visibility.GetPreviewFeatures(), Does.Contain(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026));
+    }
+
+    [TestCase(PreviewVisibility.NONE)]
+    [TestCase(PreviewVisibility.RELEASE_CANDIDATE)]
+    [TestCase(PreviewVisibility.BETA)]
+    [TestCase(PreviewVisibility.ALPHA)]
+    public void LowerLevelsDoNotOfferTheLab(PreviewVisibility visibility)
+    {
+        Assert.That(visibility.GetPreviewFeatures(), Does.Not.Contain(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026));
+    }
+
+    [Test]
+    public void LoweringTheLevelLeavesTheLabOut()
+    {
+        var enabled = new HashSet<PreviewFeatures> { PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026 };
+
+        Assert.That(PreviewVisibility.BETA.FilterPreviewFeatures(enabled), Is.Empty, "A beta level must not keep a prototype switched on.");
+    }
+
+    [Test]
+    public void TheLabIsNotReleased()
+    {
+        Assert.That(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026.IsReleased, Is.False);
+    }
+
+    [Test]
+    public void TheLabCountsOnlyWhenSwitchedOn()
+    {
+        var settingsManager = new SettingsManager(NullLogger<SettingsManager>.Instance, null!);
+        var wasEnabledBefore = PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026.IsEnabled(settingsManager);
+
+        settingsManager.ConfigurationData.App.EnabledPreviewFeatures.Add(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026);
+
+        using (Assert.EnterMultipleScope())
+        {
+            Assert.That(wasEnabledBefore, Is.False, "New settings must not switch the lab on.");
+            Assert.That(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026.IsEnabled(settingsManager), Is.True);
+        }
+    }
+
+    [Test]
+    public void TheLabHasADescription()
+    {
+        Assert.That(PreviewFeatures.PRE_BEYOND_FACTS_LAB_2026.PreviewDescription, Does.StartWith("BeyondFacts Lab"), "The settings list the preview features by this text.");
+    }
+}
@@ -0,0 +1,78 @@
+using AIStudio.Assistants.BeyondFactsLab;
+
+namespace AIStudio.Tests.BeyondFactsLab;
+
+/// <summary>
+/// Checks which preparation the BeyondFacts Lab shows after its list changed.
+/// </summary>
+[TestFixture]
+public sealed class BflProjectSelectionTests
+{
+    private static readonly BflProjectEntry CHANGED_LAST = Entry("Changed last");
+    private static readonly BflProjectEntry SELECTED_LAST = Entry("Selected last");
+    private static readonly BflProjectEntry JUST_CREATED = Entry("Just created");
+    private static readonly IReadOnlyList<BflProjectEntry> PROJECTS = [CHANGED_LAST, SELECTED_LAST, JUST_CREATED];
+
+    [Test]
+    public void ThePreparationAskedForComesFirst()
+    {
+        var chosen = BflProjectSelection.Choose(PROJECTS, JUST_CREATED.ProjectId, SELECTED_LAST.ProjectId);
+
+        Assert.That(chosen, Is.SameAs(JUST_CREATED));
+    }
+
+    [Test]
+    public void WithoutAWishThePreparationSelectedLastIsShown()
+    {
+        var chosen = BflProjectSelection.Choose(PROJECTS, null, SELECTED_LAST.ProjectId);
+
+        Assert.That(chosen, Is.SameAs(SELECTED_LAST));
+    }
+
+    [Test]
+    public void APreparationWhichIsGoneFallsBackToTheOneSelectedLast()
+    {
+        var chosen = BflProjectSelection.Choose(PROJECTS, Guid.NewGuid(), SELECTED_LAST.ProjectId);
+
+        Assert.That(chosen, Is.SameAs(SELECTED_LAST));
+    }
+
+    [Test]
+    public void WithoutAnyKnownSelectionThePreparationChangedLastIsShown()
+    {
+        var chosen = BflProjectSelection.Choose(PROJECTS, Guid.NewGuid(), Guid.NewGuid());
+
+        Assert.That(chosen, Is.SameAs(CHANGED_LAST));
+    }
+
+    [Test]
+    public void WithoutPreparationsNothingIsShown()
+    {
+        var chosen = BflProjectSelection.Choose([], Guid.NewGuid(), null);
+
+        Assert.That(chosen, Is.Null);
+    }
+
+    [Test]
+    public void APreparationWhichCannotBeOpenedCanStillBeShown()
+    {
+        var unavailable = new BflProjectEntry(Guid.NewGuid(), string.Empty, DateTimeOffset.UtcNow, BflProjectLoadStatus.UNAVAILABLE, null);
+
+        var chosen = BflProjectSelection.Choose([CHANGED_LAST, unavailable], unavailable.ProjectId, null);
+
+        Assert.That(chosen, Is.SameAs(unavailable));
+    }
+
+    private static BflProjectEntry Entry(string name)
+    {
+        var project = new BflProject
+        {
+            ProjectId = Guid.NewGuid(),
+            Name = name,
+            CreatedAtUtc = DateTimeOffset.UtcNow,
+            ModifiedAtUtc = DateTimeOffset.UtcNow,
+        };
+
+        return BflProjectEntry.FromProject(project);
+    }
+}