Added the research on individual participants to the BeyondFacts Lab (#1207)

This commit is contained in:
Thorsten Sommer authored and GitHub committed 2026-11-15 15:39:34 +01:00
1 parent 3ca4b3878b
commit 92d0ff68f4
69 files changed
+3869 -186

No files matched your search

@@ -0,0 +1,206 @@
using AIStudio.Assistants.BeyondFactsLab;
using Microsoft.Extensions.Logging.Abstractions;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks how the BeyondFacts Lab stores the research on single people of a preparation.
/// </summary>
[TestFixture]
public sealed class BeyondFactsLabStorePersonResearchTests
{
private static readonly DateTimeOffset CREATED_AT_UTC = new(2026, 11, 15, 10, 0, 0, TimeSpan.Zero);
private string dataDirectory = string.Empty;
[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 APreparationWithoutResearchOnPeopleHasNone()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
using (Assert.EnterMultipleScope())
{
Assert.That(await store.LoadPersonResearchAsync(created.ProjectId, "Eva Klein"), Is.Null);
Assert.That(await store.LoadAllPersonResearchAsync(created.ProjectId), Is.Empty);
}
}
[Test]
public async Task TheResearchOnAPersonIsStoredUnderTheIdOfTheName()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var research = new BflPersonResearch { Name = "Eva Klein" };
research.Set(BflPersonResearchStage.PROFILE, new BflResearch
{
Text = "## Profil\n\nProfessorin",
Details = [new() { FieldId = BflFieldCatalog.EVENT_TOPIC, Value = "Klimapolitik" }],
SearchQueries = ["Eva Klein Klimapolitik"],
Pages = [new() { Title = "Profil", Url = "https://example.org/klein" }],
CreatedAtUtc = CREATED_AT_UTC,
});
var changed = await store.SavePersonResearchAsync(created.ProjectId, research);
var loaded = await this.CreateStore().LoadPersonResearchAsync(created.ProjectId, "eva klein");
var all = await this.CreateStore().LoadAllPersonResearchAsync(created.ProjectId);
using (Assert.EnterMultipleScope())
{
Assert.That(loaded, Is.Not.Null);
Assert.That(loaded!.Name, Is.EqualTo("Eva Klein"));
Assert.That(loaded.Stages.Single().Stage, Is.EqualTo(BflPersonResearchStage.PROFILE));
Assert.That(loaded.StageOf(BflPersonResearchStage.PROFILE)!.Text, Is.EqualTo("## Profil\n\nProfessorin"));
Assert.That(loaded.StageOf(BflPersonResearchStage.PROFILE)!.SearchQueries, Is.EqualTo(new[] { "Eva Klein Klimapolitik" }));
Assert.That(loaded.StageOf(BflPersonResearchStage.PROFILE)!.CreatedAtUtc, Is.EqualTo(CREATED_AT_UTC));
Assert.That(all.Single().Name, Is.EqualTo("Eva Klein"));
Assert.That(changed.ModifiedAtUtc, Is.GreaterThanOrEqualTo(created.ModifiedAtUtc));
Assert.That(File.Exists(Path.Combine(this.PersonDirectory(created.ProjectId), $"{BflPersonId.Of("Eva Klein"):D}.json")), Is.True);
}
}
[Test]
public async Task AStoredStageIsWrittenAsStage()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var research = new BflPersonResearch { Name = "Eva Klein" };
research.Set(BflPersonResearchStage.APPEARANCES, new BflResearch { Text = "Text", CreatedAtUtc = CREATED_AT_UTC });
await store.SavePersonResearchAsync(created.ProjectId, research);
var json = await File.ReadAllTextAsync(Path.Combine(this.PersonDirectory(created.ProjectId), $"{BflPersonId.Of("Eva Klein"):D}.json"));
Assert.That(json, Does.Contain("\"stage\": \"APPEARANCES\""));
}
[Test]
public async Task ADamagedResearchOnAPersonStaysAsItIs()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var path = await this.WriteFileAsync(created.ProjectId, $"{BflPersonId.Of("Eva Klein"):D}.json", "{ not json");
using (Assert.EnterMultipleScope())
{
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadPersonResearchAsync(created.ProjectId, "Eva Klein"));
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SavePersonResearchAsync(created.ProjectId, new BflPersonResearch { Name = "Eva Klein" }));
Assert.That(await store.LoadAllPersonResearchAsync(created.ProjectId), Is.Empty);
Assert.That(await File.ReadAllTextAsync(path), Is.EqualTo("{ not json"));
}
}
[Test]
public async Task AResearchOnAPersonOfANewerVersionStaysAsItIs()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
await this.WriteFileAsync(created.ProjectId, $"{BflPersonId.Of("Eva Klein"):D}.json", $$"""{ "schemaVersion": {{BflPersonResearch.CURRENT_SCHEMA_VERSION + 1}}, "name": "Eva Klein", "stages": [] }""");
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadPersonResearchAsync(created.ProjectId, "Eva Klein"));
}
[Test]
public async Task AResearchUnderTheNameOfAnotherPersonIsRefused()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
await this.WriteFileAsync(created.ProjectId, $"{BflPersonId.Of("Eva Klein"):D}.json", """{ "schemaVersion": 1, "name": "Frank Ott", "stages": [] }""");
using (Assert.EnterMultipleScope())
{
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadPersonResearchAsync(created.ProjectId, "Eva Klein"));
Assert.That(await store.LoadAllPersonResearchAsync(created.ProjectId), Is.Empty);
}
}
[Test]
public async Task OtherFilesInTheFolderAreNoResearchOnPeople()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
await this.WriteFileAsync(created.ProjectId, "notes.json", """{ "schemaVersion": 1, "name": "Eva Klein", "stages": [] }""");
Assert.That(await store.LoadAllPersonResearchAsync(created.ProjectId), Is.Empty);
}
[Test]
public async Task TheSelectionOfParticipantsIsStoredBesideTheResearch()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var selection = new BflParticipantSelection { Names = ["Eva Klein", "Frank Ott"], Source = BflParticipantSelectionSource.SUGGESTION, ListCreatedAtUtc = CREATED_AT_UTC };
await store.SaveParticipantSelectionAsync(created.ProjectId, selection);
var loaded = await this.CreateStore().LoadParticipantSelectionAsync(created.ProjectId);
using (Assert.EnterMultipleScope())
{
Assert.That(loaded, Is.Not.Null);
Assert.That(loaded!.Names, Is.EqualTo(new[] { "Eva Klein", "Frank Ott" }));
Assert.That(loaded.Source, Is.EqualTo(BflParticipantSelectionSource.SUGGESTION));
Assert.That(loaded.ListCreatedAtUtc, Is.EqualTo(CREATED_AT_UTC));
Assert.That(await store.LoadAllPersonResearchAsync(created.ProjectId), Is.Empty);
Assert.That(File.Exists(Path.Combine(this.PersonDirectory(created.ProjectId), "..", "participant-selection.json")), Is.True);
}
}
[Test]
public async Task APreparationWithoutASelectionOfParticipantsHasNone()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
Assert.That(await store.LoadParticipantSelectionAsync(created.ProjectId), Is.Null);
}
[Test]
public async Task ADamagedSelectionOfParticipantsStaysAsItIs()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
var path = await this.WriteFileAsync(created.ProjectId, Path.Combine("..", "participant-selection.json"), """{ "schemaVersion": 1, "names": [ null ] }""");
using (Assert.EnterMultipleScope())
{
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadParticipantSelectionAsync(created.ProjectId));
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.SaveParticipantSelectionAsync(created.ProjectId, new BflParticipantSelection()));
Assert.That(await File.ReadAllTextAsync(path), Is.EqualTo("""{ "schemaVersion": 1, "names": [ null ] }"""));
}
}
[Test]
public async Task ResearchOnAPersonOfAMissingPreparationIsNotStored()
{
var store = this.CreateStore();
await Assert.ThrowsAsync<FileNotFoundException>(async () => await store.SavePersonResearchAsync(Guid.NewGuid(), new BflPersonResearch { Name = "Eva Klein" }));
}
private async Task<string> WriteFileAsync(Guid projectId, string fileName, string content)
{
var directory = this.PersonDirectory(projectId);
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, fileName);
await File.WriteAllTextAsync(path, content);
return path;
}
private string PersonDirectory(Guid projectId) => Path.Combine(this.dataDirectory, BeyondFactsLabStore.ROOT_DIRECTORY_NAME, projectId.ToString("D"), "steps", "05-strategy", "research", "participants");
private BeyondFactsLabStore CreateStore() => new(NullLogger<BeyondFactsLabStore>.Instance, new BflStorageOptions { DataDirectory = this.dataDirectory });
}
@@ -50,6 +50,7 @@ public sealed class BeyondFactsLabStoreResearchTests
Details = [new() { FieldId = BflFieldCatalog.EVENT_TOPIC, Value = "Klimapolitik" }],
SearchQueries = ["Podium Klimapolitik"],
Pages = [new() { Title = "Programm", Url = "https://example.org/programm" }],
Participants = [new() { Name = "Person A", Entry = "- Rolle: Podium" }],
CreatedAtUtc = new DateTimeOffset(2026, 11, 10, 14, 0, 0, TimeSpan.Zero),
};
@@ -64,6 +65,8 @@ public sealed class BeyondFactsLabStoreResearchTests
Assert.That(loaded.Details.Single().Value, Is.EqualTo("Klimapolitik"));
Assert.That(loaded.SearchQueries, Is.EqualTo(new[] { "Podium Klimapolitik" }));
Assert.That(loaded.Pages.Single().Url, Is.EqualTo("https://example.org/programm"));
Assert.That(loaded.Participants.Single().Name, Is.EqualTo("Person A"));
Assert.That(loaded.Participants.Single().Entry, Is.EqualTo("- Rolle: Podium"));
Assert.That(loaded.CreatedAtUtc, Is.EqualTo(research.CreatedAtUtc));
Assert.That(all.Keys, Is.EquivalentTo(new[] { BflResearchTopic.PARTICIPANTS }));
Assert.That(changed.ModifiedAtUtc, Is.GreaterThanOrEqualTo(created.ModifiedAtUtc));
@@ -97,6 +100,33 @@ public sealed class BeyondFactsLabStoreResearchTests
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadResearchAsync(created.ProjectId, BflResearchTopic.DEBATE));
}
[Test]
public async Task AResearchStoredBeforeTheListOfPeopleHasAnEmptyList()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
await this.WriteResearchFileAsync(created.ProjectId, "participants.json", """{ "schemaVersion": 1, "text": "### Person A", "details": [], "searchQueries": [], "pages": [] }""");
var loaded = await store.LoadResearchAsync(created.ProjectId, BflResearchTopic.PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(loaded, Is.Not.Null);
Assert.That(loaded!.Text, Is.EqualTo("### Person A"));
Assert.That(loaded.Participants, Is.Empty);
}
}
[Test]
public async Task AResearchWithAPersonWithoutANameStaysAsItIs()
{
var store = this.CreateStore();
var created = await store.CreateAsync("Panel");
await this.WriteResearchFileAsync(created.ProjectId, "participants.json", """{ "schemaVersion": 2, "text": "Text", "details": [], "searchQueries": [], "pages": [], "participants": [ { "name": null, "entry": "" } ] }""");
await Assert.ThrowsAsync<InvalidDataException>(async () => await store.LoadResearchAsync(created.ProjectId, BflResearchTopic.PARTICIPANTS));
}
[Test]
public async Task ResearchForAMissingPreparationIsNotStored()
{
@@ -0,0 +1,227 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Tools.ToolCallingSystem;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks how the BeyondFacts Lab selects whom of the list of participants to research in depth: the suggestion of the
/// model, which the lab checks strictly, and the selection which counts for a list.
/// </summary>
[TestFixture]
public sealed class BflParticipantSelectionTests
{
private static readonly DateTimeOffset CREATED_AT_UTC = new(2026, 11, 15, 10, 0, 0, TimeSpan.Zero);
private static readonly BflParticipant[] PARTICIPANTS =
[
new() { Name = "Eva Klein", Entry = "- Rolle: Podium" },
new() { Name = "Frank Ott", Entry = "- Rolle: Moderation" },
new() { Name = "Ida Lux", Entry = "- Rolle: Keynote" },
];
[Test]
public void ASuggestionWithNamesFromTheListIsAcceptedInTheSpellingOfTheList()
{
var check = BflParticipantSelectionCheck.Read("Hier ist meine Auswahl:\n```json\n{ \"participants\": [ \"frank OTT\", \"Eva Klein\" ] }\n```", PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Problems, Is.Empty);
Assert.That(check.Names, Is.EqualTo(new[] { "Frank Ott", "Eva Klein" }));
}
}
[Test]
public void ASuggestionWithANameWhichIsNotOnTheListIsRejectedAsAWhole()
{
var check = BflParticipantSelectionCheck.Read("""{ "participants": [ "Eva Klein", "Anna Erfunden" ] }""", PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Names, Is.Empty);
Assert.That(check.Problems, Is.EqualTo(new[] { "„Anna Erfunden“ steht nicht in der Liste der Teilnehmenden." }));
}
}
[Test]
public void ASuggestionWithANameTwiceIsRejected()
{
var check = BflParticipantSelectionCheck.Read("""{ "participants": [ "Eva Klein", "eva klein" ] }""", PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Names, Is.Empty);
Assert.That(check.Problems, Is.EqualTo(new[] { "„Eva Klein“ steht mehr als einmal in der Auswahl." }));
}
}
[Test]
public void ASuggestionWithTooManyNamesIsRejected()
{
var participants = Enumerable.Range(1, BflParticipantSelection.MAX_SUGGESTED_PEOPLE + 1).Select(number => new BflParticipant { Name = $"Person {number}" }).ToList();
var answer = $$"""{ "participants": [ {{string.Join(", ", participants.Select(participant => $"\"{participant.Name}\""))}} ] }""";
var check = BflParticipantSelectionCheck.Read(answer, participants);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Names, Is.Empty);
Assert.That(check.Problems.Single(), Does.Contain($"höchstens {BflParticipantSelection.MAX_SUGGESTED_PEOPLE}"));
}
}
[TestCase("""{ "participants": [] }""", "Die Auswahl ist leer; sie braucht mindestens einen Namen.")]
[TestCase("""{ "participants": [ " " ] }""", "Ein Eintrag der Auswahl ist leer.")]
[TestCase("""{ "people": [ "Eva Klein" ] }""", "Das Feld „participants“ fehlt.")]
[TestCase("Eva Klein und Frank Ott", "Die Antwort enthält kein vollständiges JSON-Objekt.")]
public void AnEmptyOrIncompleteSuggestionIsRejected(string answer, string problem)
{
var check = BflParticipantSelectionCheck.Read(answer, PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Names, Is.Empty);
Assert.That(check.Problems, Does.Contain(problem));
}
}
[Test]
public void ASuggestionWhichNamesTheFieldTwiceIsRejected()
{
var check = BflParticipantSelectionCheck.Read("""{ "participants": [ "Eva Klein" ], "participants": [ "Frank Ott" ] }""", PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(check.Names, Is.Empty);
Assert.That(check.Problems.Single(), Does.StartWith("Das JSON-Objekt ist nicht lesbar"));
}
}
[Test]
public void AShortListCountsAsSelectedAsAWholeUntilSomebodyChooses()
{
var list = List(PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(BflParticipantSelection.SelectedIn(list, null).Select(participant => participant.Name), Is.EqualTo(PARTICIPANTS.Select(participant => participant.Name)));
Assert.That(BflParticipantSelection.NeedsSuggestion(list, null), Is.False);
}
}
[Test]
public void ALongListCountsAsNotSelectedAndNeedsASuggestion()
{
var list = List([.. Enumerable.Range(1, BflParticipantSelection.MAX_SUGGESTED_PEOPLE + 1).Select(number => new BflParticipant { Name = $"Person {number}" })]);
using (Assert.EnterMultipleScope())
{
Assert.That(BflParticipantSelection.SelectedIn(list, null), Is.Empty);
Assert.That(BflParticipantSelection.NeedsSuggestion(list, null), Is.True);
}
}
[Test]
public void ASelectionCountsForItsListInTheOrderOfTheList()
{
var list = List(PARTICIPANTS);
var selection = new BflParticipantSelection { Names = ["ida lux", "Eva Klein", "Nicht Gelistet"], ListCreatedAtUtc = CREATED_AT_UTC };
Assert.That(BflParticipantSelection.SelectedIn(list, selection).Select(participant => participant.Name), Is.EqualTo(new[] { "Eva Klein", "Ida Lux" }));
}
[Test]
public void ASelectionForAnEarlierListNoLongerCounts()
{
var list = List([.. Enumerable.Range(1, BflParticipantSelection.MAX_SUGGESTED_PEOPLE + 1).Select(number => new BflParticipant { Name = $"Person {number}" })]);
var earlier = new BflParticipantSelection { Names = ["Person 1"], ListCreatedAtUtc = CREATED_AT_UTC.AddDays(-1) };
var current = new BflParticipantSelection { Names = ["Person 1"], ListCreatedAtUtc = CREATED_AT_UTC };
using (Assert.EnterMultipleScope())
{
Assert.That(BflParticipantSelection.SelectedIn(list, earlier), Is.Empty);
Assert.That(BflParticipantSelection.NeedsSuggestion(list, earlier), Is.True);
Assert.That(BflParticipantSelection.SelectedIn(list, current).Single().Name, Is.EqualTo("Person 1"));
Assert.That(BflParticipantSelection.NeedsSuggestion(list, current), Is.False);
}
}
[Test]
public async Task TheSuggestionKnowsTheFirstThreeStepsAndTheListButNothingConfided()
{
var forms = BflStep.All.ToDictionary(step => step, _ => new BflStepFormData());
foreach (var field in BflFieldCatalog.FIELDS.Where(field => field.Kind is not (BflFieldKind.CHOICE or BflFieldKind.MULTI_CHOICE)))
forms[field.Step].Set(field.Id, $"MARKER-{field.Id}");
var template = await BflPromptLibrary.ReadAsync(BflPromptLibrary.PARTICIPANT_SELECTION_PATH);
var prompt = BflPromptComposer.ComposeParticipantSelection(template, forms, PARTICIPANTS);
using (Assert.EnterMultipleScope())
{
Assert.That(prompt, Does.Contain("### Eva Klein\n- Rolle: Podium"));
Assert.That(prompt, Does.Contain($"höchstens {BflParticipantSelection.MAX_SUGGESTED_PEOPLE} Personen"));
Assert.That(prompt, Does.Contain($"MARKER-{BflFieldCatalog.CONTRIBUTION_TOPIC}"));
foreach (var field in BflFieldCatalog.FIELDS.Where(field => field.Kind is not (BflFieldKind.CHOICE or BflFieldKind.MULTI_CHOICE)))
{
if (field.Step >= BflStep.VALUES_AND_PERSPECTIVES || field.IsPersonalDisclosure)
Assert.That(prompt, Does.Not.Contain($"MARKER-{field.Id}"), field.Id);
}
}
}
[Test]
public void TheSuggestionHasNoPlaceForMoreThanTheDetailsAndTheList()
{
using (Assert.EnterMultipleScope())
{
Assert.That(BflPromptLibrary.PlaceholdersOf(BflPromptLibrary.PARTICIPANT_SELECTION_PATH), Is.EquivalentTo(new[] { BflPromptTemplate.SELECTION_SIZE, BflPromptTemplate.DETAILS, BflPromptTemplate.PARTICIPANTS }));
Assert.That(BflPromptLibrary.AllPaths, Does.Contain(BflPromptLibrary.PARTICIPANT_SELECTION_PATH));
}
}
[Test]
public async Task TheRequestNamesSectionsOfThePromptOfTheSelection()
{
var prompt = (await BflPromptLibrary.ReadAsync(BflPromptLibrary.PARTICIPANT_SELECTION_PATH)).ReplaceLineEndings("\n");
var request = BflResearchRunner.SELECTION_REQUEST;
using (Assert.EnterMultipleScope())
{
foreach (var section in new[] { "Vorgehen", "Form" })
{
Assert.That(request, Does.Contain($"„{section}“"));
Assert.That(prompt, Does.Contain($"\n# {section}\n"));
}
}
}
[Test]
public void TheRepairRequestNamesEveryProblem()
{
var request = BflPromptComposer.ComposeParticipantSelectionRepairRequest(["Erstes Problem.", "Zweites Problem."]);
using (Assert.EnterMultipleScope())
{
Assert.That(request, Does.Contain("- Erstes Problem.\n- Zweites Problem."));
Assert.That(request, Does.Contain("nur mit Namen aus der Liste"));
}
}
[Test]
public void AChatWithoutToolsGetsNoTool()
{
var provider = new AIStudio.Settings.Provider(1, "provider-1", "Test", AIStudio.Provider.LLMProviders.SELF_HOSTED, new AIStudio.Provider.Model("model", null));
var hidden = BflThreadFactory.CreateHidden("participant-selection");
BflThreadFactory.PrepareForRequest(hidden, provider, "Prompt");
using (Assert.EnterMultipleScope())
{
Assert.That(hidden.RuntimeSelectedToolIds, Is.Empty);
Assert.That(hidden.RuntimeSelectedToolIds, Does.Not.Contain(ToolSelectionRules.WEB_SEARCH_TOOL_ID));
Assert.That(hidden.RuntimeToolsAreAssistantManaged, Is.True);
}
}
private static BflResearch List(IReadOnlyList<BflParticipant> participants) => new() { Participants = [.. participants], CreatedAtUtc = CREATED_AT_UTC };
}
@@ -0,0 +1,109 @@
using AIStudio.Assistants.BeyondFactsLab;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks how the BeyondFacts Lab reads the list of people from the research on the participants.
/// </summary>
[TestFixture]
public sealed class BflParticipantTests
{
[Test]
public void EveryHeadingOfTheThirdLevelIsAPersonWithTheTextBelowIt()
{
const string TEXT = "## Programm\n\n[Programm](https://example.org/programm)\n\n## Teilnehmende\n\n### Eva Klein\n\n- Rolle: Podium\n- Quelle: [Programm](https://example.org/programm)\n\n### Frank Ott\n\n- Rolle: Moderation\n\n## Offene Punkte\n\n- Wer noch?";
var participants = BflParticipant.ListIn(TEXT);
using (Assert.EnterMultipleScope())
{
Assert.That(participants.Select(participant => participant.Name), Is.EqualTo(new[] { "Eva Klein", "Frank Ott" }));
Assert.That(participants[0].Entry, Is.EqualTo("- Rolle: Podium\n- Quelle: [Programm](https://example.org/programm)"));
Assert.That(participants[1].Entry, Is.EqualTo("- Rolle: Moderation"));
}
}
[Test]
public void AHeadingOfALowerLevelBelongsToTheEntry()
{
var participants = BflParticipant.ListIn("### Eva Klein\n\n#### Rolle\n\nPodium\n# Ende\n\nNicht mehr dazu");
using (Assert.EnterMultipleScope())
{
Assert.That(participants.Single().Name, Is.EqualTo("Eva Klein"));
Assert.That(participants.Single().Entry, Is.EqualTo("#### Rolle\n\nPodium"));
}
}
[Test]
public void MarkdownInAHeadingIsTakenOff()
{
var participants = BflParticipant.ListIn("### **Eva Klein**\n### [Frank Ott](https://example.org/ott) ###\n### `Ida Lux`");
Assert.That(participants.Select(participant => participant.Name), Is.EqualTo(new[] { "Eva Klein", "Frank Ott", "Ida Lux" }));
}
[Test]
public void EmptyAndOverlongHeadingsAreNoPeople()
{
var participants = BflParticipant.ListIn($"### \n### ** **\n### {new string('A', BflParticipant.MAX_NAME_CHARACTERS + 1)}\n### Eva Klein");
Assert.That(participants.Select(participant => participant.Name), Is.EqualTo(new[] { "Eva Klein" }));
}
[Test]
public void ANameWhichComesTwiceCountsOnceWithItsFirstEntry()
{
var participants = BflParticipant.ListIn("### Eva Klein\n\nPodium\n\n### eva KLEIN\n\nModeration");
using (Assert.EnterMultipleScope())
{
Assert.That(participants.Single().Name, Is.EqualTo("Eva Klein"));
Assert.That(participants.Single().Entry, Is.EqualTo("Podium"));
}
}
[Test]
public void AListHoldsAtMostTheLargestNumberOfPeople()
{
var text = string.Join("\n", Enumerable.Range(1, BflParticipant.MAX_PARTICIPANTS + 5).Select(number => $"### Person {number}\n\nEintrag {number}"));
var participants = BflParticipant.ListIn(text);
using (Assert.EnterMultipleScope())
{
Assert.That(participants, Has.Count.EqualTo(BflParticipant.MAX_PARTICIPANTS));
Assert.That(participants[^1].Entry, Is.EqualTo($"Eintrag {BflParticipant.MAX_PARTICIPANTS}"));
}
}
[Test]
public void LinesEndingInCarriageReturnAndLineFeedAreRead()
{
var participants = BflParticipant.ListIn("### Eva Klein\r\n\r\nPodium\r\n### Frank Ott");
using (Assert.EnterMultipleScope())
{
Assert.That(participants.Select(participant => participant.Name), Is.EqualTo(new[] { "Eva Klein", "Frank Ott" }));
Assert.That(participants[0].Entry, Is.EqualTo("Podium"));
}
}
[Test]
public void AnAnswerWithoutHeadingsListsNobody()
{
Assert.That(BflParticipant.ListIn("Die Recherche fand keine Teilnehmenden."), Is.Empty);
}
[Test]
public void ANameIsTheSameRegardlessOfCaseAndSpaces()
{
var participant = new BflParticipant { Name = "Eva Klein" };
using (Assert.EnterMultipleScope())
{
Assert.That(participant.HasName(" eva KLEIN "), Is.True);
Assert.That(participant.HasName("Eva Kleine"), Is.False);
}
}
}
@@ -0,0 +1,114 @@
using AIStudio.Assistants.BeyondFactsLab;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks how the research on single people reaches the step "Strategy" of the BeyondFacts Lab.
/// </summary>
[TestFixture]
public sealed class BflPersonResearchInStrategyTests
{
private static readonly BflPromptParts PARTS = new("{{RESEARCH}}", "Leitfaden", "Schritt", "Anrede", string.Empty);
private static readonly DateTimeOffset CREATED_AT_UTC = new(2026, 11, 15, 10, 0, 0, TimeSpan.Zero);
[Test]
public void OnlyTheStepStrategyCarriesTheResearchOnPeople()
{
var forms = Forms("Klimapolitik");
var people = new[] { Person(forms, "Eva Klein", BflPersonResearchStage.All) };
using (Assert.EnterMultipleScope())
{
foreach (var step in BflStep.All)
{
var prompt = BflPromptComposer.Compose(PARTS, step, forms, [], "Deutsch", people: people);
if (step is BflStep.STRATEGY)
{
Assert.That(prompt, Does.Contain("<person name=\"Eva Klein\">"));
Assert.That(prompt, Does.Contain($"<stufe titel=\"{BflPersonResearchStage.POSITIONS.Title}\" stand=\"2026-11-15\">\nText {BflPersonResearchStage.POSITIONS}\n</stufe>"));
Assert.That(prompt, Does.Not.Contain("endete vor ihrer letzten Stufe"));
}
else
{
Assert.That(prompt, Does.Not.Contain("Eva Klein"), step.ToString());
}
}
}
}
[Test]
public void AnEventWhichIsNotPublicCarriesNoResearchOnPeople()
{
var forms = Forms("Klimapolitik");
var people = new[] { Person(forms, "Eva Klein", BflPersonResearchStage.All) };
forms[BflStep.FRAMEWORK].Set(BflFieldCatalog.EVENT_VISIBILITY, BflFieldCatalog.EVENT_NOT_PUBLIC);
var prompt = BflPromptComposer.Compose(PARTS, BflStep.STRATEGY, forms, [], "Deutsch", people: people);
Assert.That(prompt, Does.Not.Contain("Eva Klein"));
}
[Test]
public void AnIncompleteOrOutdatedResearchOnAPersonIsMarked()
{
var people = new[] { Person(Forms("Energiepolitik"), "Eva Klein", [BflPersonResearchStage.PROFILE]) };
var prompt = BflPromptComposer.Compose(PARTS, BflStep.STRATEGY, Forms("Klimapolitik"), [], "Deutsch", people: people);
using (Assert.EnterMultipleScope())
{
Assert.That(prompt, Does.Contain("(Diese Recherche endete vor ihrer letzten Stufe; es fehlen Teile.)"));
Assert.That(prompt, Does.Contain("(Die öffentlichen Angaben haben sich seit dieser Recherche geändert."));
Assert.That(prompt, Does.Not.Contain($"titel=\"{BflPersonResearchStage.POSITIONS.Title}\""));
}
}
[Test]
public void OnlyThePeopleOfTheCurrentListCountInTheOrderOfTheList()
{
var forms = Forms("Klimapolitik");
var list = BflResearch.Of("### Frank Ott\n\n### Eva Klein", [], [], BflPromptComposer.PublicDetailsOf(forms), CREATED_AT_UTC);
list.Participants = [.. BflParticipant.ListIn(list.Text)];
var topics = new Dictionary<BflResearchTopic, BflResearch> { [BflResearchTopic.PARTICIPANTS] = list };
BflPersonResearch[] stored = [Person(forms, "eva klein", BflPersonResearchStage.All), Person(forms, "Nicht Mehr Gelistet", BflPersonResearchStage.All), Person(forms, "Frank Ott", BflPersonResearchStage.All)];
var research = BflStepResearch.Of(topics, stored);
using (Assert.EnterMultipleScope())
{
Assert.That(research.Topics, Is.SameAs(topics));
Assert.That(research.People.Select(person => person.Name), Is.EqualTo(new[] { "Frank Ott", "eva klein" }));
Assert.That(BflStepResearch.Of(new Dictionary<BflResearchTopic, BflResearch>(), stored).People, Is.Empty);
}
}
[Test]
public void APersonWithoutTextIsLeftOut()
{
var forms = Forms("Klimapolitik");
var empty = new BflPersonResearch { Name = "Eva Klein" };
empty.Set(BflPersonResearchStage.PROFILE, BflResearch.Of(" ", [], [], BflPromptComposer.PublicDetailsOf(forms), CREATED_AT_UTC));
var prompt = BflPromptComposer.Compose(PARTS, BflStep.STRATEGY, forms, [], "Deutsch", people: [empty]);
Assert.That(prompt, Is.EqualTo("Es gibt noch keine Recherche."));
}
private static BflPersonResearch Person(IReadOnlyDictionary<BflStep, BflStepFormData> forms, string name, IEnumerable<BflPersonResearchStage> stages)
{
var person = new BflPersonResearch { Name = name };
foreach (var stage in stages)
person.Set(stage, BflResearch.Of($"Text {stage}", [], [], BflPromptComposer.PublicDetailsOf(forms), CREATED_AT_UTC));
return person;
}
private static Dictionary<BflStep, BflStepFormData> Forms(string eventTopic)
{
var forms = BflStep.All.ToDictionary(step => step, _ => new BflStepFormData());
forms[BflStep.FRAMEWORK].Set(BflFieldCatalog.FORMAT, "Podium");
forms[BflStep.FRAMEWORK].Set(BflFieldCatalog.EVENT_TOPIC, eventTopic);
return forms;
}
}
@@ -0,0 +1,168 @@
using AIStudio.Assistants.BeyondFactsLab;
using AIStudio.Tools.ToolCallingSystem;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks what the agents of the research on a person of the BeyondFacts Lab receive: the public details about the
/// event, the entry of the person in the list of participants, what earlier stages found, and nothing else of a
/// preparation.
/// </summary>
[TestFixture]
public sealed class BflPersonResearchPromptTests
{
private static readonly DateTimeOffset CREATED_AT_UTC = new(2026, 11, 15, 10, 0, 0, TimeSpan.Zero);
private static readonly BflParticipant PARTICIPANT = new() { Name = "Eva Klein", Entry = "- Rolle: Podium\n- Institution: TUM" };
[Test]
public async Task OnlyPublicContentReachesTheResearchOnAPerson()
{
var forms = FormsWithAMarkerInEveryField();
var details = BflPromptComposer.PublicDetailsOf(forms);
foreach (var stage in BflPersonResearchStage.All)
{
var prompt = BflPromptComposer.ComposePersonResearch(await BflPromptLibrary.LoadPersonResearchPartsAsync(stage), details, PARTICIPANT, [], "Deutsch");
using (Assert.EnterMultipleScope())
{
Assert.That(prompt, Does.Contain("Name: Eva Klein"), stage.ToString());
Assert.That(prompt, Does.Contain("- Rolle: Podium\n- Institution: TUM"), stage.ToString());
foreach (var field in TextFields())
{
if (field.IsSharedWithResearch)
Assert.That(prompt, Does.Contain(Marker(field)), $"{stage}: {field.Id}");
else
Assert.That(prompt, Does.Not.Contain(Marker(field)), $"{stage}: {field.Id}");
}
}
}
}
[Test]
public void TheResearchOnAPersonHasNoPlaceForAnythingButPublicContent()
{
var placeholders = BflPromptLibrary.PlaceholdersOf(BflPromptLibrary.PERSON_RESEARCH_PATH);
using (Assert.EnterMultipleScope())
{
Assert.That(placeholders, Is.EquivalentTo(new[] { BflPromptTemplate.RESPONSE_LANGUAGE, BflPromptTemplate.TOPIC, BflPromptTemplate.TOOL_CALLS, BflPromptTemplate.PERSON, BflPromptTemplate.EARLIER_STAGES, BflPromptTemplate.PUBLIC_DETAILS }));
foreach (var stage in BflPersonResearchStage.All)
Assert.That(BflPromptLibrary.PlaceholdersOf(BflPromptLibrary.PersonResearchStagePath(stage)), Is.Empty, stage.ToString());
}
}
[Test]
public async Task EveryStageHasATaskOfItsOwn()
{
var paths = BflPersonResearchStage.All.Select(BflPromptLibrary.PersonResearchStagePath).ToList();
using (Assert.EnterMultipleScope())
{
Assert.That(paths, Is.Unique);
Assert.That(paths.Intersect(BflResearchTopic.All.Select(BflPromptLibrary.ResearchTopicPath)), Is.Empty);
Assert.That(BflPromptLibrary.AllPaths, Is.SupersetOf(paths).And.Contains(BflPromptLibrary.PERSON_RESEARCH_PATH));
foreach (var path in paths)
Assert.That(await BflPromptLibrary.ReadAsync(path), Is.Not.Empty, path);
}
}
[Test]
public async Task ALaterStageLearnsWhatTheEarlierStagesFound()
{
var profile = new BflPersonResearch { Name = PARTICIPANT.Name };
profile.Set(BflPersonResearchStage.PROFILE, BflResearch.Of("## Person\n\nProfessorin für Klimaökonomie", [], [], [], CREATED_AT_UTC));
var first = BflPromptComposer.ComposePersonResearch(await BflPromptLibrary.LoadPersonResearchPartsAsync(BflPersonResearchStage.PROFILE), [], PARTICIPANT, [], "Deutsch");
var second = BflPromptComposer.ComposePersonResearch(await BflPromptLibrary.LoadPersonResearchPartsAsync(BflPersonResearchStage.POSITIONS), [], PARTICIPANT, profile.Stages, "Deutsch");
using (Assert.EnterMultipleScope())
{
Assert.That(first, Does.Contain("Du bist die erste Stufe; es gibt noch keine Ergebnisse."));
Assert.That(second, Does.Contain($"<stufe titel=\"{BflPersonResearchStage.PROFILE.Title}\" stand=\"2026-11-15\">\n## Person\n\nProfessorin für Klimaökonomie\n</stufe>"));
Assert.That(second, Does.Not.Contain("Du bist die erste Stufe"));
}
}
[Test]
public void APersonWithoutAnEntryIsKnownByTheNameOnly()
{
var prompt = BflPromptComposer.ComposePersonResearch(new("{{PERSON}}", "Auftrag"), [], new BflParticipant { Name = "Frank Ott" }, [], "Deutsch");
Assert.That(prompt, Is.EqualTo("Name: Frank Ott\n\nDie Liste nennt nur den Namen."));
}
[Test]
public void ADetailOfAFieldWhichIsNotPublicIsLeftOut()
{
BflResearchDetail[] details =
[
new() { FieldId = BflFieldCatalog.EVENT_TOPIC, Value = "Klimapolitik" },
new() { FieldId = BflFieldCatalog.CONTRIBUTION_TOPIC, Value = "Unveröffentlichte Studie" },
];
var prompt = BflPromptComposer.ComposePersonResearch(new("{{PUBLIC_DETAILS}}", "Auftrag"), details, PARTICIPANT, [], "Deutsch");
using (Assert.EnterMultipleScope())
{
Assert.That(prompt, Does.Contain("Klimapolitik"));
Assert.That(prompt, Does.Not.Contain("Unveröffentlichte Studie"));
}
}
[Test]
public async Task TheAgentOfAStageKnowsItsBudgetOfToolCalls()
{
var prompt = BflPromptComposer.ComposePersonResearch(await BflPromptLibrary.LoadPersonResearchPartsAsync(BflPersonResearchStage.APPEARANCES), [], PARTICIPANT, [], "Deutsch");
Assert.That(prompt, Does.Contain($"höchstens {ToolSelectionRules.MAX_TOOL_CALLS} Werkzeugaufrufe"));
}
[Test]
public async Task TheRequestNamesSectionsOfThePromptOfThePeople()
{
var prompt = (await BflPromptLibrary.ReadAsync(BflPromptLibrary.PERSON_RESEARCH_PATH)).ReplaceLineEndings("\n");
var request = BflResearchRunner.REQUEST;
using (Assert.EnterMultipleScope())
{
foreach (var section in new[] { "Dein Auftrag", "Vorgehen", "Form" })
{
Assert.That(request, Does.Contain($"„{section}“"));
Assert.That(prompt, Does.Contain($"\n# {section}\n"));
}
}
}
[Test]
public void AStageKeepsLessTextThanATopic()
{
var answer = string.Join("\n", Enumerable.Repeat(new string('x', 99), 200));
var topic = BflResearch.Of(answer, [], [], [], CREATED_AT_UTC);
var stage = BflResearch.Of(answer, [], [], [], CREATED_AT_UTC, BflPersonResearch.MAX_STAGE_TEXT_CHARACTERS);
using (Assert.EnterMultipleScope())
{
Assert.That(stage.Text.Length, Is.LessThanOrEqualTo(BflPersonResearch.MAX_STAGE_TEXT_CHARACTERS));
Assert.That(stage.Text.Length, Is.LessThan(topic.Text.Length));
Assert.That(stage.Text, Does.EndWith("x"));
}
}
private static IEnumerable<BflFieldDefinition> TextFields() => BflFieldCatalog.FIELDS.Where(field => field.Kind is not (BflFieldKind.CHOICE or BflFieldKind.MULTI_CHOICE));
private static string Marker(BflFieldDefinition field) => $"MARKER-{field.Id}";
private static Dictionary<BflStep, BflStepFormData> FormsWithAMarkerInEveryField()
{
var forms = BflStep.All.ToDictionary(step => step, _ => new BflStepFormData());
foreach (var field in TextFields())
forms[field.Step].Set(field.Id, Marker(field));
foreach (var field in BflFieldCatalog.FIELDS.Where(field => field.Kind is BflFieldKind.CHOICE or BflFieldKind.MULTI_CHOICE))
forms[field.Step].SetChoices(field, [field.Options[0].Id]);
return forms;
}
}
@@ -0,0 +1,107 @@
using AIStudio.Assistants.BeyondFactsLab;
namespace AIStudio.Tests.BeyondFactsLab;
/// <summary>
/// Checks the research of the BeyondFacts Lab on one person: its stages, its ID, and when it is outdated.
/// </summary>
[TestFixture]
public sealed class BflPersonResearchTests
{
private static readonly DateTimeOffset CREATED_AT_UTC = new(2026, 11, 15, 10, 0, 0, TimeSpan.Zero);
private static readonly BflResearchDetail[] DETAILS =
[
new() { FieldId = BflFieldCatalog.EVENT_TOPIC, Value = "Klimapolitik" },
];
[Test]
public void TheStagesKeepTheirOrderWhateverOrderTheyAreSetIn()
{
var research = new BflPersonResearch { Name = "Eva Klein" };
research.Set(BflPersonResearchStage.APPEARANCES, Research("Auftreten", 3));
research.Set(BflPersonResearchStage.PROFILE, Research("Profil", 1));
using (Assert.EnterMultipleScope())
{
Assert.That(research.Stages.Select(stage => stage.Stage), Is.EqualTo(new[] { BflPersonResearchStage.PROFILE, BflPersonResearchStage.APPEARANCES }));
Assert.That(research.StageOf(BflPersonResearchStage.PROFILE)!.Text, Is.EqualTo("Profil"));
Assert.That(research.StageOf(BflPersonResearchStage.POSITIONS), Is.Null);
Assert.That(research.IsComplete, Is.False);
Assert.That(research.LastCreatedAtUtc, Is.EqualTo(CREATED_AT_UTC.AddMinutes(3)));
}
}
[Test]
public void AStageSetAgainReplacesWhatItFoundBefore()
{
var research = new BflPersonResearch { Name = "Eva Klein" };
research.Set(BflPersonResearchStage.POSITIONS, Research("Alt", 1));
research.Set(BflPersonResearchStage.POSITIONS, Research("Neu", 2));
using (Assert.EnterMultipleScope())
{
Assert.That(research.Stages, Has.Count.EqualTo(1));
Assert.That(research.StageOf(BflPersonResearchStage.POSITIONS)!.Text, Is.EqualTo("Neu"));
}
}
[Test]
public void AResearchWithEveryStageIsComplete()
{
var research = new BflPersonResearch { Name = "Eva Klein" };
foreach (var stage in BflPersonResearchStage.All)
research.Set(stage, Research(stage.FileStem, 1));
Assert.That(research.IsComplete, Is.True);
}
[Test]
public void AResearchWithoutStagesHasNoTime()
{
Assert.That(new BflPersonResearch { Name = "Eva Klein" }.LastCreatedAtUtc, Is.Null);
}
[Test]
public void AResearchIsOutdatedOnceOneOfItsStagesIs()
{
var research = new BflPersonResearch { Name = "Eva Klein" };
research.Set(BflPersonResearchStage.PROFILE, Research("Profil", 1));
BflResearchDetail[] changed = [new() { FieldId = BflFieldCatalog.EVENT_TOPIC, Value = "Energiepolitik" }];
using (Assert.EnterMultipleScope())
{
Assert.That(research.IsOutdated(DETAILS), Is.False);
Assert.That(research.IsOutdated(changed), Is.True);
}
}
[Test]
public void TheIdOfAPersonFollowsFromTheNameAlone()
{
using (Assert.EnterMultipleScope())
{
Assert.That(BflPersonId.Of("Eva Klein"), Is.EqualTo(BflPersonId.Of(" eva KLEIN ")));
Assert.That(BflPersonId.Of("Eva Klein"), Is.Not.EqualTo(BflPersonId.Of("Eva Kleine")));
Assert.That(BflPersonId.Of("Eva Klein").Version, Is.EqualTo(8));
Assert.That(BflPersonId.Of("Eva Klein"), Is.Not.EqualTo(BflThreadId.ONBOARDING));
}
}
[Test]
public void EveryStageHasATitleADescriptionAndAFile()
{
foreach (var stage in BflPersonResearchStage.All)
{
using (Assert.EnterMultipleScope())
{
Assert.That(stage.Title, Is.Not.Empty);
Assert.That(stage.Description, Is.Not.Empty);
Assert.That(stage.FileStem, Is.Not.Empty);
}
}
}
private static BflResearch Research(string text, int minutes) => BflResearch.Of(text, [], [], DETAILS, CREATED_AT_UTC.AddMinutes(minutes));
}
@@ -169,6 +169,16 @@ public sealed class BflShareModelBuilderTests
Assert.That(session, Does.Contain($"{BflResearchTopic.EVENT.Title}, {BflResearchTopic.DEBATE.Title}"));
}
[Test]
public void TheNumberOfThePeopleResearchedInDepthAppears()
{
using (Assert.EnterMultipleScope())
{
Assert.That(Build(researchedPeople: 3), Does.Contain("- **People researched in depth:** 3\n"));
Assert.That(Build(), Does.Contain("- **People researched in depth:** 0\n"));
}
}
[Test]
public void EveryStepAppearsInItsOrder()
{
@@ -227,13 +237,14 @@ public sealed class BflShareModelBuilderTests
Assert.That(Build(forms: forms, valueDeck: deck), Does.Not.Contain("Card sort"));
}
private static string Build(Dictionary<BflStep, BflStepFormData>? forms = null, IReadOnlyDictionary<BflStep, BflWorkState>? workStates = null, IReadOnlyDictionary<BflResultKind, BflResult>? results = null, IReadOnlyDictionary<BflStep, IReadOnlyList<BflConversationMessage>>? conversations = null, IReadOnlyList<BflMaterial>? materials = null, IReadOnlyCollection<BflResearchTopic>? researchTopics = null, bool includePersonalDisclosures = false, BflValueDeck? valueDeck = null) => BflShareModelBuilder.Build(new BflShareInput(
private static string Build(Dictionary<BflStep, BflStepFormData>? forms = null, IReadOnlyDictionary<BflStep, BflWorkState>? workStates = null, IReadOnlyDictionary<BflResultKind, BflResult>? results = null, IReadOnlyDictionary<BflStep, IReadOnlyList<BflConversationMessage>>? conversations = null, IReadOnlyList<BflMaterial>? materials = null, IReadOnlyCollection<BflResearchTopic>? researchTopics = null, int researchedPeople = 0, bool includePersonalDisclosures = false, BflValueDeck? valueDeck = null) => BflShareModelBuilder.Build(new BflShareInput(
forms ?? Forms(),
workStates ?? new Dictionary<BflStep, BflWorkState>(),
results ?? new Dictionary<BflResultKind, BflResult>(),
conversations ?? new Dictionary<BflStep, IReadOnlyList<BflConversationMessage>>(),
materials ?? [],
researchTopics ?? [],
researchedPeople,
includePersonalDisclosures,
"26.11.2",
NOW,
+11 -1
View File
@@ -21,18 +21,28 @@ public sealed class BflShareNamesTests
}
[Test]
public void TheHeadingsOfTheResearchOnTheParticipantsAreSuggested()
public void TheListOfPeopleOfTheResearchOnTheParticipantsIsSuggested()
{
var research = new BflResearch
{
Text = "## Teilnehmende\n\n### Dr. Eva Klein\n\n- Rolle: Podium\n\n### Frank Ott (Moderation)\n\n## Offene Punkte\n\n- Wer noch?",
CreatedAtUtc = NOW,
};
research.Participants = [.. BflParticipant.ListIn(research.Text)];
var names = BflShareNames.Suggest(Forms(), new Dictionary<BflStep, BflWorkState>(), research);
Assert.That(names, Is.EqualTo(new[] { "Eva Klein", "Frank Ott" }));
}
[Test]
public void TheHeadingsOfAResearchWithoutAListOfPeopleAreNotSuggested()
{
var research = new BflResearch { Text = "### Dr. Eva Klein", CreatedAtUtc = NOW };
var names = BflShareNames.Suggest(Forms(), new Dictionary<BflStep, BflWorkState>(), research);
Assert.That(names, Is.Empty);
}
[Test]
public void TheNamesInBoldInTheSectionOnTheParticipantsAreSuggested()
{