477 lines
19 KiB
C#
477 lines
19 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using AibisDream.Framework;
|
|
using AibisDream.SaveSystem;
|
|
using Newtonsoft.Json;
|
|
using NUnit.Framework;
|
|
using UnityEngine;
|
|
|
|
namespace AibisDream.DeveloperMode.Editor.Tests
|
|
{
|
|
public sealed class TestSaveSystemTests
|
|
{
|
|
private string _root;
|
|
private TestSaveRepository _repository;
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
_root = Path.Combine(
|
|
Path.GetTempPath(),
|
|
"AibisDream-TestSaveTests",
|
|
Guid.NewGuid().ToString("N"));
|
|
_repository = new TestSaveRepository(_root);
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown()
|
|
{
|
|
if (Directory.Exists(_root))
|
|
{
|
|
Directory.Delete(_root, true);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Record_SameAnchor_ReplacesSnapshotAndKeepsFirstSeenOrder()
|
|
{
|
|
var first = _repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneOne"));
|
|
var second = _repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneTwo"));
|
|
var scan = _repository.Scan("1.0");
|
|
|
|
Assert.That(scan.Entries.Count, Is.EqualTo(1));
|
|
Assert.That(second.Meta.firstSeenOrder, Is.EqualTo(first.Meta.firstSeenOrder));
|
|
Assert.That(scan.Entries[0].Meta.sceneName, Is.EqualTo("SceneTwo"));
|
|
Assert.That(_repository.TryLoad(scan.Entries[0], out var snapshot, out var error), Is.True, error);
|
|
Assert.That(snapshot.scene.sceneName, Is.EqualTo("SceneTwo"));
|
|
}
|
|
|
|
[Test]
|
|
public void Record_ReplacingEarlierEntry_DoesNotMoveItsOrder()
|
|
{
|
|
_repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA"));
|
|
_repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeB", "SceneB"));
|
|
_repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA2"));
|
|
|
|
var entries = _repository.Scan().Entries.ToArray();
|
|
Assert.That(entries.Select(item => item.NodeName), Is.EqualTo(new[] { "NodeA", "NodeB" }));
|
|
Assert.That(entries[0].Meta.firstSeenOrder, Is.LessThan(entries[1].Meta.firstSeenOrder));
|
|
}
|
|
|
|
[Test]
|
|
public void Scan_RetainsMissingSnapshotAsInvalid()
|
|
{
|
|
var entry = _repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA"));
|
|
File.Delete(entry.SnapshotPath);
|
|
|
|
var scan = _repository.Scan();
|
|
|
|
Assert.That(scan.ValidCount, Is.Zero);
|
|
Assert.That(scan.InvalidCount, Is.EqualTo(1));
|
|
Assert.That(scan.Entries[0].Status, Is.EqualTo(TestSaveEntryStatus.MissingSnapshot));
|
|
}
|
|
|
|
[Test]
|
|
public void Scan_RetainsOrphanSnapshotWithBrokenMeta()
|
|
{
|
|
var directory = Path.Combine(_root, "chapter", "broken");
|
|
Directory.CreateDirectory(directory);
|
|
File.WriteAllText(
|
|
Path.Combine(directory, TestSaveRepository.SnapshotFileName),
|
|
"{}",
|
|
Encoding.UTF8);
|
|
|
|
var scan = _repository.Scan();
|
|
|
|
Assert.That(scan.InvalidCount, Is.EqualTo(1));
|
|
Assert.That(scan.Entries[0].Status, Is.EqualTo(TestSaveEntryStatus.CorruptMeta));
|
|
}
|
|
|
|
[Test]
|
|
public void Validate_CorruptSnapshot_IsRetainedAndDisabledOnNextScan()
|
|
{
|
|
var entry = _repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA"));
|
|
File.WriteAllText(entry.SnapshotPath, "{broken", Encoding.UTF8);
|
|
|
|
Assert.That(_repository.Validate(entry, out var error), Is.False);
|
|
var rescanned = _repository.Scan();
|
|
|
|
Assert.That(error, Does.Contain("无法解析"));
|
|
Assert.That(rescanned.InvalidCount, Is.EqualTo(1));
|
|
Assert.That(rescanned.Entries[0].Status, Is.EqualTo(TestSaveEntryStatus.CorruptSnapshot));
|
|
}
|
|
|
|
[Test]
|
|
public void Scan_RecoversCompleteStagingDirectory()
|
|
{
|
|
var final = Path.Combine(_root, "chapter", "node");
|
|
var staging = final + ".__staging";
|
|
Directory.CreateDirectory(staging);
|
|
var request = CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA");
|
|
var meta = CreateMeta(request, 1);
|
|
File.WriteAllText(
|
|
Path.Combine(staging, TestSaveRepository.MetaFileName),
|
|
JsonConvert.SerializeObject(meta),
|
|
Encoding.UTF8);
|
|
File.WriteAllText(
|
|
Path.Combine(staging, TestSaveRepository.SnapshotFileName),
|
|
SnapshotPersistence.Serialize(request.Snapshot),
|
|
Encoding.UTF8);
|
|
|
|
var scan = _repository.Scan();
|
|
|
|
Assert.That(Directory.Exists(final), Is.True);
|
|
Assert.That(Directory.Exists(staging), Is.False);
|
|
Assert.That(scan.ValidCount, Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void Record_ConcurrentRequests_ProducesCompleteUniqueEntries()
|
|
{
|
|
var tasks = Enumerable.Range(0, 12)
|
|
.Select(index => Task.Run(() =>
|
|
_repository.Record(CreateRequest(
|
|
"ChapterA",
|
|
"ProjectA",
|
|
$"Node{index:00}",
|
|
$"Scene{index:00}"))))
|
|
.ToArray();
|
|
|
|
Task.WaitAll(tasks);
|
|
var scan = _repository.Scan();
|
|
|
|
Assert.That(scan.ValidCount, Is.EqualTo(12));
|
|
Assert.That(scan.InvalidCount, Is.Zero);
|
|
Assert.That(scan.Entries.Select(item => item.Meta.firstSeenOrder).Distinct().Count(), Is.EqualTo(12));
|
|
}
|
|
|
|
[Test]
|
|
public void DeleteInvalid_RemovesOnlyInvalidEntries()
|
|
{
|
|
_repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeA", "SceneA"));
|
|
var invalid = _repository.Record(CreateRequest("ChapterA", "ProjectA", "NodeB", "SceneB"));
|
|
File.Delete(invalid.SnapshotPath);
|
|
|
|
var removed = _repository.DeleteInvalid(out var error);
|
|
var scan = _repository.Scan();
|
|
|
|
Assert.That(error, Is.Null);
|
|
Assert.That(removed, Is.EqualTo(1));
|
|
Assert.That(scan.ValidCount, Is.EqualTo(1));
|
|
Assert.That(scan.InvalidCount, Is.Zero);
|
|
}
|
|
|
|
[TestCase(new[] { "hub" }, true)]
|
|
[TestCase(new[] { "linear" }, true)]
|
|
[TestCase(new[] { "content" }, true)]
|
|
[TestCase(new[] { "event" }, false)]
|
|
[TestCase(new[] { "hub", "no_save" }, false)]
|
|
[TestCase(new string[0], true)]
|
|
public void SilentCoverageEvaluator_MatchesSavePointTagSemantics(string[] tags, bool expected)
|
|
{
|
|
var actual = SavePointEvaluator.EvaluateNodeTagsForAutoSaveSilently(
|
|
"Node",
|
|
tags,
|
|
out _);
|
|
Assert.That(actual, Is.EqualTo(expected));
|
|
}
|
|
|
|
[TestCase(new[] { "content" }, NodeSaveTiming.NodeEnter, SaveResumeMode.RestartNode)]
|
|
[TestCase(new[] { "interaction" }, NodeSaveTiming.DialogueExit, SaveResumeMode.StateOnly)]
|
|
[TestCase(new[] { "content", "save_on_exit" }, NodeSaveTiming.DialogueExit, SaveResumeMode.StateOnly)]
|
|
[TestCase(new[] { "event", "save_on_exit" }, NodeSaveTiming.DialogueExit, SaveResumeMode.StateOnly)]
|
|
[TestCase(new[] { "interaction", "save_on_exit" }, NodeSaveTiming.DialogueExit, SaveResumeMode.StateOnly)]
|
|
[TestCase(new[] { "interaction", "no_save" }, NodeSaveTiming.None, SaveResumeMode.RestartNode)]
|
|
[TestCase(new[] { "content", "event" }, NodeSaveTiming.None, SaveResumeMode.RestartNode)]
|
|
public void ResolveNodePolicy_MapsNodeTypeAndModifiers(
|
|
string[] tags,
|
|
NodeSaveTiming expectedTiming,
|
|
SaveResumeMode expectedResumeMode)
|
|
{
|
|
var policy = SavePointEvaluator.ResolveNodePolicy(
|
|
"Node",
|
|
tags,
|
|
out _,
|
|
logWarnings: false);
|
|
|
|
Assert.That(policy.Timing, Is.EqualTo(expectedTiming));
|
|
Assert.That(policy.ResumeMode, Is.EqualTo(expectedResumeMode));
|
|
}
|
|
|
|
[Test]
|
|
public void Repository_StateOnlySnapshot_PreservesAnchorNode()
|
|
{
|
|
var request = CreateRequest("ChapterA", "ProjectA", "InteractionNode", "SceneA");
|
|
request.Snapshot.anchor.startDialogueOnRestore = false;
|
|
request.SaveTrigger = "DialogueExit";
|
|
request.ResumeMode = nameof(SaveResumeMode.StateOnly);
|
|
request.StartDialogueOnRestore = false;
|
|
request.DedupeKey = TestSaveRecorder.BuildDedupeKey(
|
|
request.SceneSoName,
|
|
request.YarnProjectId,
|
|
request.NodeName,
|
|
request.ResumeMode);
|
|
request.EntryId = TestSaveRepository.StableHash(request.DedupeKey);
|
|
|
|
var entry = _repository.Record(request);
|
|
var loaded = _repository.TryLoad(entry, out var snapshot, out var error);
|
|
|
|
Assert.That(loaded, Is.True, error);
|
|
Assert.That(entry.NodeName, Is.EqualTo("InteractionNode"));
|
|
Assert.That(entry.ResumeMode, Is.EqualTo(nameof(SaveResumeMode.StateOnly)));
|
|
Assert.That(snapshot.anchor.nodeName, Is.EqualTo("InteractionNode"));
|
|
Assert.That(snapshot.anchor.startDialogueOnRestore, Is.False);
|
|
}
|
|
|
|
[Test]
|
|
public void SnapshotPersistence_MissingRestoreFlag_IsRejected()
|
|
{
|
|
const string json =
|
|
"{\"schemaVersion\":2,\"anchor\":{\"sceneSoName\":\"ChapterA\"," +
|
|
"\"yarnProjectId\":\"ProjectA\",\"nodeName\":\"NodeA\"}}";
|
|
|
|
Assert.Throws<Newtonsoft.Json.JsonSerializationException>(
|
|
() => SnapshotPersistence.Deserialize(json));
|
|
}
|
|
|
|
[Test]
|
|
public void SerialTaskQueue_DoesNotDropOrReorderRequests()
|
|
{
|
|
var queue = new SerialTaskQueue();
|
|
var releaseFirst = new TaskCompletionSource<bool>();
|
|
var firstStarted = new TaskCompletionSource<bool>();
|
|
var order = new List<int>();
|
|
|
|
var first = queue.Enqueue(async () =>
|
|
{
|
|
order.Add(1);
|
|
firstStarted.SetResult(true);
|
|
await releaseFirst.Task;
|
|
order.Add(2);
|
|
});
|
|
var second = queue.Enqueue(() =>
|
|
{
|
|
order.Add(3);
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
Assert.That(firstStarted.Task.Wait(TimeSpan.FromSeconds(2)), Is.True);
|
|
Assert.That(order, Is.EqualTo(new[] { 1 }));
|
|
Assert.That(queue.PendingCount, Is.EqualTo(2));
|
|
|
|
releaseFirst.SetResult(true);
|
|
Assert.That(
|
|
Task.WaitAll(
|
|
new[] { first.Completion, second.Completion },
|
|
TimeSpan.FromSeconds(2)),
|
|
Is.True);
|
|
|
|
Assert.That(first.Sequence, Is.LessThan(second.Sequence));
|
|
Assert.That(order, Is.EqualTo(new[] { 1, 2, 3 }));
|
|
}
|
|
|
|
[Test]
|
|
public void SaveRequest_MapsResumeModeToExplicitAnchorFlag()
|
|
{
|
|
var enter = SaveRequest.NodeEnter("NodeA", "ProjectA", "ChapterA", 3, 7);
|
|
var exit = SaveRequest.DialogueExit("NodeB", "ProjectA", "ChapterA", 3, 9);
|
|
|
|
Assert.That(enter.AnchorSpec.NodeName, Is.EqualTo("NodeA"));
|
|
Assert.That(enter.AnchorSpec.StartDialogueOnRestore, Is.True);
|
|
Assert.That(exit.AnchorSpec.NodeName, Is.EqualTo("NodeB"));
|
|
Assert.That(exit.AnchorSpec.StartDialogueOnRestore, Is.False);
|
|
}
|
|
|
|
[TestCase(false, "DetourNode", true)]
|
|
[TestCase(false, "NoSaveNode", false)]
|
|
[TestCase(true, "AnotherNode", true)]
|
|
public void ValidateDialogueTiming_NonExitRequestIgnoresLaterDialogueState(
|
|
bool explicitCommand,
|
|
string currentNodeName,
|
|
bool isDialogueRunning)
|
|
{
|
|
var request = explicitCommand
|
|
? SaveRequest.Explicit("SourceNode", "ProjectA", "ChapterA", 3, 7)
|
|
: SaveRequest.NodeEnter("SourceNode", "ProjectA", "ChapterA", 3, 7);
|
|
|
|
var valid = SaveRestoreOrchestrator.ValidateDialogueTiming(
|
|
request,
|
|
currentDialogueRunId: 99,
|
|
currentFlowRevision: 101,
|
|
currentNodeName: currentNodeName,
|
|
isDialogueRunning: isDialogueRunning,
|
|
out var reason);
|
|
|
|
Assert.That(valid, Is.True, reason);
|
|
Assert.That(request.AnchorSpec.NodeName, Is.EqualTo("SourceNode"));
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateDialogueTiming_ConsecutiveNodeEnterRequestsRemainEligible()
|
|
{
|
|
var first = SaveRequest.NodeEnter("FirstNode", "ProjectA", "ChapterA", 3, 7);
|
|
var second = SaveRequest.NodeEnter("SecondNode", "ProjectA", "ChapterA", 3, 8);
|
|
|
|
var firstValid = SaveRestoreOrchestrator.ValidateDialogueTiming(
|
|
first,
|
|
currentDialogueRunId: 3,
|
|
currentFlowRevision: 8,
|
|
currentNodeName: "SecondNode",
|
|
isDialogueRunning: true,
|
|
out var firstReason);
|
|
var secondValid = SaveRestoreOrchestrator.ValidateDialogueTiming(
|
|
second,
|
|
currentDialogueRunId: 3,
|
|
currentFlowRevision: 8,
|
|
currentNodeName: "SecondNode",
|
|
isDialogueRunning: true,
|
|
out var secondReason);
|
|
|
|
Assert.That(firstValid, Is.True, firstReason);
|
|
Assert.That(secondValid, Is.True, secondReason);
|
|
Assert.That(first.AnchorSpec.NodeName, Is.EqualTo("FirstNode"));
|
|
Assert.That(second.AnchorSpec.NodeName, Is.EqualTo("SecondNode"));
|
|
}
|
|
|
|
[Test]
|
|
public void ValidateDialogueTiming_DialogueExitAcceptsStableCompletedFlow()
|
|
{
|
|
var request = SaveRequest.DialogueExit(
|
|
"InteractionNode",
|
|
"ProjectA",
|
|
"ChapterA",
|
|
3,
|
|
9);
|
|
|
|
var valid = SaveRestoreOrchestrator.ValidateDialogueTiming(
|
|
request,
|
|
currentDialogueRunId: 3,
|
|
currentFlowRevision: 9,
|
|
currentNodeName: null,
|
|
isDialogueRunning: false,
|
|
out var reason);
|
|
|
|
Assert.That(valid, Is.True, reason);
|
|
}
|
|
|
|
[TestCase(4, 9, null, false, "dialogue run changed")]
|
|
[TestCase(3, 10, null, false, "flow revision changed")]
|
|
[TestCase(3, 9, "DetourNode", false, "current Yarn node")]
|
|
[TestCase(3, 9, "NoSaveNode", false, "current Yarn node")]
|
|
[TestCase(3, 9, "JumpTarget", true, "still running")]
|
|
public void ValidateDialogueTiming_DialogueExitRejectsChangedOrRunningFlow(
|
|
long currentDialogueRunId,
|
|
long currentFlowRevision,
|
|
string currentNodeName,
|
|
bool isDialogueRunning,
|
|
string expectedReason)
|
|
{
|
|
var request = SaveRequest.DialogueExit(
|
|
"InteractionNode",
|
|
"ProjectA",
|
|
"ChapterA",
|
|
3,
|
|
9);
|
|
|
|
var valid = SaveRestoreOrchestrator.ValidateDialogueTiming(
|
|
request,
|
|
currentDialogueRunId,
|
|
currentFlowRevision,
|
|
currentNodeName,
|
|
isDialogueRunning,
|
|
out var reason);
|
|
|
|
Assert.That(valid, Is.False);
|
|
Assert.That(reason, Does.Contain(expectedReason));
|
|
}
|
|
|
|
[Test]
|
|
public void InteractionLock_ComposesWithDialogueLock()
|
|
{
|
|
var gameObject = new GameObject("EventSystemEx-Test");
|
|
try
|
|
{
|
|
var eventSystem = gameObject.AddComponent<EventSystemEx>();
|
|
EnumEventSystem.Global.Send(InteractionEventEnum.DialogStart);
|
|
var checkpointLock = eventSystem.AcquireInteractionLock("test");
|
|
|
|
EnumEventSystem.Global.Send(InteractionEventEnum.DialogEnd);
|
|
Assert.That(eventSystem.isLocked, Is.True);
|
|
|
|
checkpointLock.Dispose();
|
|
Assert.That(eventSystem.isLocked, Is.False);
|
|
}
|
|
finally
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(gameObject);
|
|
}
|
|
}
|
|
|
|
private static TestSaveRecordRequest CreateRequest(
|
|
string sceneSoName,
|
|
string yarnProject,
|
|
string nodeName,
|
|
string sceneName)
|
|
{
|
|
var key = TestSaveRecorder.BuildDedupeKey(sceneSoName, yarnProject, nodeName);
|
|
return new TestSaveRecordRequest
|
|
{
|
|
Snapshot = new SaveSnapshot
|
|
{
|
|
gameVersion = "1.0",
|
|
savedAt = "2026-01-01 00:00:00",
|
|
scene = new SceneSnapshotDto { sceneName = sceneName },
|
|
anchor = new AnchorSnapshot
|
|
{
|
|
sceneSoName = sceneSoName,
|
|
yarnProjectId = yarnProject,
|
|
nodeName = nodeName,
|
|
startDialogueOnRestore = true
|
|
}
|
|
},
|
|
DedupeKey = key,
|
|
EntryId = TestSaveRepository.StableHash(key),
|
|
ChapterId = sceneSoName,
|
|
ChapterTitle = sceneSoName,
|
|
SceneSoName = sceneSoName,
|
|
YarnProjectId = yarnProject,
|
|
NodeName = nodeName,
|
|
SaveTrigger = "NodeEnter",
|
|
ResumeMode = nameof(SaveResumeMode.RestartNode),
|
|
StartDialogueOnRestore = true,
|
|
SceneName = sceneName,
|
|
GameVersion = "1.0"
|
|
};
|
|
}
|
|
|
|
private static TestSaveMeta CreateMeta(TestSaveRecordRequest request, long order)
|
|
{
|
|
return new TestSaveMeta
|
|
{
|
|
entryId = request.EntryId,
|
|
dedupeKey = request.DedupeKey,
|
|
chapterId = request.ChapterId,
|
|
chapterTitle = request.ChapterTitle,
|
|
sceneSoName = request.SceneSoName,
|
|
yarnProjectId = request.YarnProjectId,
|
|
nodeName = request.NodeName,
|
|
saveTrigger = request.SaveTrigger,
|
|
resumeMode = request.ResumeMode,
|
|
startDialogueOnRestore = request.StartDialogueOnRestore,
|
|
sceneName = request.SceneName,
|
|
firstSeenOrder = order,
|
|
firstRecordedAt = "2026-01-01 00:00:00",
|
|
lastRecordedAt = "2026-01-01 00:00:00",
|
|
snapshotSchemaVersion = SaveSnapshotSchema.CurrentVersion,
|
|
gameVersion = request.GameVersion
|
|
};
|
|
}
|
|
}
|
|
}
|
|
#endif
|