Add speech-topic policy from tomorrow and a morning family talk.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-20 13:53:12 +03:00
parent 5e147a8e47
commit 92c2143329
31 changed files with 909 additions and 35 deletions
@@ -113,6 +113,53 @@ public class TalkCirclesTests
        Assert.True(high > low);
    }

+    [Fact]
+    public void StudyOnlyPolicy_NeverPicksNonStudyTopic()
+    {
+        var (catalog, _, _) = World();
+        var picker = Person("a", ["RussianLanguage"]);
+        for (var i = 0; i < 80; i++)
+        {
+            var id = TalkCircles.PickTopic(catalog, picker, age: 14, seed: i * 137, speechPolicy: SpeechPolicies.StudyOnly);
+            Assert.NotNull(id);
+            Assert.Contains(TopicTags.Study, catalog.Topics[id].Tags, StringComparer.Ordinal);
+        }
+    }
+
+    [Fact]
+    public void NoRudePolicy_NeverPicksRudeTopic()
+    {
+        var (catalog, _, _) = World();
+        var picker = Person("a", ["RussianLanguage"]);
+        var rudeUnderFree = 0;
+        for (var i = 0; i < 11_000; i++)
+        {
+            var freeId = TalkCircles.PickTopic(catalog, picker, age: 14, seed: i, speechPolicy: SpeechPolicies.Free);
+            if (freeId is not null && catalog.Topics[freeId].Tags.Contains(TopicTags.Rude, StringComparer.Ordinal))
+            {
+                rudeUnderFree++;
+            }
+
+            var filtered = TalkCircles.PickTopic(catalog, picker, age: 14, seed: i, speechPolicy: SpeechPolicies.NoRude);
+            Assert.NotNull(filtered);
+            Assert.DoesNotContain(TopicTags.Rude, catalog.Topics[filtered].Tags, StringComparer.Ordinal);
+        }
+
+        Assert.True(rudeUnderFree > 0);
+    }
+
+    [Fact]
+    public void FamilyTaggedTopic_IsFromTopicDef()
+    {
+        var (catalog, _, _) = World();
+        var id = TalkCircles.PickTaggedTopic(catalog, TopicTags.Family, seed: 1);
+        Assert.NotNull(id);
+        Assert.Contains(TopicTags.Family, catalog.Topics[id].Tags, StringComparer.Ordinal);
+        var schoolShift = catalog.Topics[id].OpinionShift;
+        var home = (int)Math.Round(schoolShift * catalog.BehaviorRules!.HomeTalkOpinionScale, MidpointRounding.AwayFromZero);
+        Assert.True(Math.Abs(home) < Math.Abs(schoolShift) || schoolShift == 0);
+    }
+
    [Fact]
    public void Enemies_AreNotRankedAsInvitees()
    {
@@ -0,0 +1,74 @@
+using System.Net;
+using System.Net.Http.Json;
+
+namespace HSchool.AppHost.Tests;
+
+[Collection(AppHostCollection.Name)]
+public class SpeechRulesApiTests(AppHostFixture fixture)
+{
+    private static readonly DateTime Start = new(2012, 4, 3, 6, 0, 0, DateTimeKind.Utc);
+
+    [Fact]
+    public async Task NewSchool_DefaultSpeech_IsFree()
+    {
+        using var client = fixture.App.CreateHttpClient("server");
+        await SchoolApiTests.ResetAsync(client);
+        var school = await SchoolApiTests.CreateAsync(client, "Речь дефолт", Start, seed: 46);
+
+        var response = await client.GetAsync($"/api/schools/{school.Id}/speech-rules", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        var rules = await response.Content.ReadFromJsonAsync<SpeechRulesDto>(TestContext.Current.CancellationToken);
+        Assert.NotNull(rules);
+        Assert.Equal("free", rules.Students);
+        Assert.Equal("free", rules.Staff);
+        Assert.Null(rules.PendingStudents);
+        Assert.Null(rules.PendingStaff);
+    }
+
+    [Fact]
+    public async Task PostStudyOnlyToday_QueuesPending_LeavesLiveFree()
+    {
+        using var client = fixture.App.CreateHttpClient("server");
+        await SchoolApiTests.ResetAsync(client);
+        var school = await SchoolApiTests.CreateAsync(client, "Речь завтра", Start, seed: 46);
+
+        var post = await client.PostAsJsonAsync(
+            $"/api/schools/{school.Id}/speech-rules",
+            new { students = "studyOnly" },
+            TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, post.StatusCode);
+        var queued = await post.Content.ReadFromJsonAsync<SpeechRulesDto>(TestContext.Current.CancellationToken);
+        Assert.NotNull(queued);
+        Assert.Equal("free", queued.Students);
+        Assert.Equal("studyOnly", queued.PendingStudents);
+
+        var get = await client.GetFromJsonAsync<SpeechRulesDto>(
+            $"/api/schools/{school.Id}/speech-rules",
+            TestContext.Current.CancellationToken);
+        Assert.NotNull(get);
+        Assert.Equal("free", get.Students);
+        Assert.Equal("studyOnly", get.PendingStudents);
+    }
+
+    [Fact]
+    public async Task UnknownPolicy_Returns400()
+    {
+        using var client = fixture.App.CreateHttpClient("server");
+        await SchoolApiTests.ResetAsync(client);
+        var school = await SchoolApiTests.CreateAsync(client, "Плохая речь", Start, seed: 46);
+
+        using var response = await client.PostAsJsonAsync(
+            $"/api/schools/{school.Id}/speech-rules",
+            new { students = "silence" },
+            TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.Equal("unknown-speech", await SchoolApiTests.ProblemCodeAsync(response));
+    }
+
+    private sealed record SpeechRulesDto(
+        string Students,
+        string Staff,
+        string? PendingStudents,
+        string? PendingStaff);
+}
@@ -63,6 +63,47 @@ public class MorningOpinionsTests
        Assert.True(after < before);
    }

+    [Fact]
+    public void SkipFridayToMonday_AppliesHomeEventAndDrift()
+    {
+        var fridayEvening = new DateTime(2012, 4, 6, 22, 0, 0, DateTimeKind.Utc);
+        using var school = OpenEmpty(fridayEvening);
+        var child = school.Roster!.People.First(person => person.IsStudent && !person.IsParent);
+        var classmate = school.Roster.People.First(person =>
+            person.IsStudent
+            && !person.Id.Equals(child.Id, StringComparison.Ordinal)
+            && !OpinionStore.FamilyMemberIds(school.Roster, child).Contains(person.Id));
+        var family = school.Roster.Families.Single(row => row.Id.Equals(child.FamilyId, StringComparison.Ordinal));
+        var parentId = family.ParentIds
+            .OrderBy(id => id, StringComparer.Ordinal)
+            .First(id => school.Roster.People.Any(person => person.Id.Equals(id, StringComparison.Ordinal)));
+        var rules = school.Catalog!.BehaviorRules!;
+        var parentStart = rules.OpinionChildToParentStart;
+
+        OpinionStore.Set(child, parentId, parentStart);
+        OpinionStore.Set(child, classmate.Id, 30);
+
+        Assert.True(school.TrySkipEmpty().Succeeded);
+        Assert.Equal(new DateTime(2012, 4, 9, 6, 0, 0, DateTimeKind.Utc), school.Clock.Time);
+
+        Assert.True(child.Opinions.TryGetValue(parentId, out var parentView));
+        Assert.NotEqual(parentStart, parentView);
+
+        Assert.True(child.Opinions.TryGetValue(classmate.Id, out var classmateView));
+        Assert.True(classmateView < 30);
+        Assert.True(classmateView <= 30 - rules.OpinionDriftPerMorning);
+
+        var schoolShift = school.Catalog.Topics.Values
+            .Where(topic => !topic.Abstract && topic.Tags.Contains(TopicTags.Family, StringComparer.Ordinal))
+            .Select(topic => Math.Abs(topic.OpinionShift))
+            .DefaultIfEmpty(2)
+            .Max();
+        Assert.True(Math.Abs(parentView - parentStart) < schoolShift);
+        Assert.Contains(
+            school.DayLog,
+            row => row.PersonId == child.Id && row.Type.Equals(PersonLogTypes.HomeTalk, StringComparison.Ordinal));
+    }
+
    private static void AdvanceTo(School school, DateTime until)
    {
        while (school.Clock.Time < until)
@@ -151,6 +151,75 @@ public class TalkCircleTests
        }
    }

+    [Fact]
+    public void PendingStudyOnlyToday_DoesNotChangeCurrentGamesCircle()
+    {
+        var (school, first, second) = TwoPupilsOnBreak();
+        using (school)
+        {
+            OpinionStore.Set(first, second.Id, 55);
+            OpinionStore.Set(second, first.Id, 55);
+            PlaceAt(school, first.Id, "corridor-1");
+            PlaceAt(school, second.Id, "corridor-1");
+            Assert.True(school.TryStartAction(first.Id, TalkActions.Chat));
+            var live = school.TalkCirclesById.Values.Single();
+            live.TopicId = "TopicGames";
+
+            school.SpeechRules = school.SpeechRules.WithPending(SpeechPolicies.StudyOnly, null);
+            Assert.Equal(SpeechPolicies.Free, school.SpeechRules.Students);
+
+            TalkCircleSystem.Apply(school, 0.5d);
+            Assert.Equal("TopicGames", school.TalkCircleOf(first.Id)?.TopicId);
+            Assert.Equal(SpeechPolicies.StudyOnly, school.SpeechRules.PendingStudents);
+        }
+    }
+
+    [Fact]
+    public void AfterWorkMorning_NoRudePolicy_StudentsDoNotStartRudeTopic()
+    {
+        var (school, first, second) = TwoPupilsOnBreak();
+        using (school)
+        {
+            school.SpeechRules = school.SpeechRules.WithPending(SpeechPolicies.NoRude, null);
+            MorningDress.Apply(school);
+            Assert.Equal(SpeechPolicies.NoRude, school.SpeechRules.Students);
+            Assert.Null(school.SpeechRules.PendingStudents);
+
+            TalkCircleSystem.Interrupt(school, first.Id);
+            TalkCircleSystem.Interrupt(school, second.Id);
+            PlaceAt(school, first.Id, "corridor-1");
+            PlaceAt(school, second.Id, "corridor-1");
+            OpinionStore.Set(first, second.Id, 55);
+            OpinionStore.Set(second, first.Id, 55);
+
+            var started = 0;
+            var classmates = school.Roster!.Classes.First(row => row.RoomId == "classroom-101").PupilIds
+                .Select(id => school.Roster.People.First(person => person.Id == id))
+                .ToArray();
+            foreach (var initiator in classmates)
+            {
+                TalkCircleSystem.Interrupt(school, initiator.Id);
+                PlaceAt(school, initiator.Id, "corridor-1");
+                PlaceAt(school, first.Id, "corridor-1");
+                PlaceAt(school, second.Id, "corridor-1");
+                if (!school.TryStartAction(initiator.Id, TalkActions.Chat))
+                {
+                    continue;
+                }
+
+                started++;
+                var circle = school.TalkCircleOf(initiator.Id);
+                Assert.NotNull(circle);
+                Assert.False(
+                    school.Catalog!.Topics[circle.TopicId].Tags.Contains(TopicTags.Rude, StringComparer.Ordinal),
+                    circle.TopicId);
+                TalkCircleSystem.Interrupt(school, initiator.Id);
+            }
+
+            Assert.True(started > 0);
+        }
+    }
+
    private static (School School, Person First, Person Second) TwoPupilsWithPhonesOnBreak()
    {
        var (catalog, map) = Vanilla();