using AcDream.UI.Abstractions.Panels.Chat;
namespace AcDream.UI.Abstractions.Tests.Panels.Chat;
///
/// TDD coverage for . Pure function:
/// no fakes, no setup. Each prefix in the holtburger
/// chat.rs alias table gets at least one round-trip test plus
/// every documented edge case.
///
public sealed class ChatInputParserTests
{
// -- Default channel (no prefix / explicit /say) --------------------
[Fact]
public void NoPrefix_UsesDefaultChannelLiteral()
{
var parsed = ChatInputParser.Parse("hello world", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Say, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal("hello world", parsed.Value.Text);
}
[Fact]
public void SayPrefix_StripsTheSlashSay()
{
var parsed = ChatInputParser.Parse("/say hi there", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Say, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal("hi there", parsed.Value.Text);
}
// -- Tell aliases ----------------------------------------------------
[Fact]
public void TellPrefix_FullForm_ParsesTargetAndMessage()
{
var parsed = ChatInputParser.Parse("/tell Bestie hi there", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Bestie", parsed.Value.TargetName);
Assert.Equal("hi there", parsed.Value.Text);
}
[Fact]
public void TellPrefix_ShortForm_ParsesTargetAndMessage()
{
var parsed = ChatInputParser.Parse("/t Bestie hi", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Bestie", parsed.Value.TargetName);
Assert.Equal("hi", parsed.Value.Text);
}
[Fact]
public void TellPrefix_MultiWordTarget_ChompsFirstTokenAsTarget()
{
// Holtburger split_once on whitespace: first token is target.
// "/t Sir Lancelot hello" -> target="Sir", text="Lancelot hello".
var parsed = ChatInputParser.Parse("/t Sir Lancelot hello", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Sir", parsed.Value.TargetName);
Assert.Equal("Lancelot hello", parsed.Value.Text);
}
[Theory]
[InlineData("/t Caith, hi", "Caith")]
[InlineData("/t Caith: hi", "Caith")]
[InlineData("/t Caith; hi", "Caith")]
[InlineData("/t Caith. hi", "Caith")]
[InlineData("/t Caith! hi", "Caith")]
[InlineData("/t Caith? hi", "Caith")]
[InlineData("/tell Caith, hi", "Caith")]
public void TellPrefix_StripsTrailingPunctuationFromTarget(string raw, string expectedTarget)
{
// Retail muscle memory: "/t Name, message" — comma is the
// separator. Filed after a 2026-04-25 live-launch session
// where typing "/t je, hello" produced target="je," and the
// server responded with WeenieError 0x052B (CharacterNotAvailable)
// because no character "je," exists. Strip a trailing
// ,;:.!? from the target so both forms work.
var parsed = ChatInputParser.Parse(raw, ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal(expectedTarget, parsed.Value.TargetName);
Assert.Equal("hi", parsed.Value.Text);
}
// -- Reply aliases ---------------------------------------------------
[Fact]
public void ReplyPrefix_UsesLastIncomingTellSenderAsTarget()
{
var parsed = ChatInputParser.Parse("/r back at you", ChatChannelKind.Say, lastTellSender: "Bestie");
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Bestie", parsed.Value.TargetName);
Assert.Equal("back at you", parsed.Value.Text);
}
[Fact]
public void ReplyPrefix_NoLastSender_ReturnsNull()
{
var parsed = ChatInputParser.Parse("/r hi", ChatChannelKind.Say, lastTellSender: null);
Assert.Null(parsed);
}
[Fact]
public void RpAlias_IsReply_NotRoleplay()
{
// Campaign CH slice CH4 (2026-08-09), Tier 1 fix #2: retail's own
// help text confirms "@reply ... You may also use @r or
// @rp." — a private reply, not a Roleplay broadcast.
var parsed = ChatInputParser.Parse("/rp back at you", ChatChannelKind.Say, lastTellSender: "Bestie");
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Bestie", parsed.Value.TargetName);
Assert.Equal("back at you", parsed.Value.Text);
}
[Fact]
public void TellAliases_SendWhisperW_AllRouteAsTell()
{
// Campaign CH slice CH4 (2026-08-09): retail's DoTell registers
// FOUR verb strings — tell/t/send/whisper/w.
foreach (string verb in new[] { "/send", "/whisper", "/w" })
{
var parsed = ChatInputParser.Parse($"{verb} Bestie hi", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Bestie", parsed.Value.TargetName);
Assert.Equal("hi", parsed.Value.Text);
}
}
[Fact]
public void RetellAlias_Rt_RoutesLikeRetell()
{
var parsed = ChatInputParser.Parse(
"/rt once more",
ChatChannelKind.Say,
lastTellSender: null,
lastOutgoingTellTarget: "Caith");
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal("Caith", parsed.Value.TargetName);
Assert.Equal("once more", parsed.Value.Text);
}
[Theory]
[InlineData("/tell Aunt Agatha, hello", "Aunt Agatha", "hello")]
[InlineData("/t Aunt Agatha, hello", "Aunt Agatha", "hello")]
public void TellTarget_SplitsOnFirstComma_NotFirstWhitespace(string raw, string expectedTarget, string expectedText)
{
// Campaign CH slice CH4 (2026-08-09), Tier 1 fix #6 (A.3): retail's
// DoTell requires a comma after the name precisely because names
// can be multiple words. Splitting on the first WHITESPACE (the
// pre-CH4 behavior) truncated "Aunt Agatha" to "Aunt".
var parsed = ChatInputParser.Parse(raw, ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Tell, parsed!.Value.Channel);
Assert.Equal(expectedTarget, parsed.Value.TargetName);
Assert.Equal(expectedText, parsed.Value.Text);
}
// -- Channel aliases (single-message) -------------------------------
[Theory]
// Campaign CH slice CH4 (2026-08-09), Tier 1 fix #1: "/g" is
// Fellowship in retail (g/group/party/fellow/fellows/fellowship all
// bind 0x800), NOT General — sending fellowship chatter to General
// was a live correctness bug.
[InlineData("/g raid time", ChatChannelKind.Fellowship, "raid time")]
[InlineData("/f buff up", ChatChannelKind.Fellowship, "buff up")]
[InlineData("/a swearing in", ChatChannelKind.Allegiance, "swearing in")]
[InlineData("/m monarch broadcast", ChatChannelKind.Monarch, "monarch broadcast")]
[InlineData("/p patron only", ChatChannelKind.Patron, "patron only")]
[InlineData("/v vassals only", ChatChannelKind.Vassals, "vassals only")]
// "/cv" (an acdream invention) is DELETED; "/c" is the real retail
// Co-vassals alias (registry doc §2.3).
[InlineData("/c covassals only", ChatChannelKind.CoVassals, "covassals only")]
[InlineData("/lfg need 3 more", ChatChannelKind.Lfg, "need 3 more")]
[InlineData("/trade wts gem", ChatChannelKind.Trade, "wts gem")]
// "/role" (an acdream invention) is DELETED; "/roleplay" is retail's
// real verb (see LongFormAliases_RouteToTheirChannel for the full
// roleplay/reply-alias split).
[InlineData("/roleplay *waves*", ChatChannelKind.Roleplay, "*waves*")]
[InlineData("/society olthoi raid", ChatChannelKind.Society, "olthoi raid")]
[InlineData("/olthoi for the queen", ChatChannelKind.Olthoi, "for the queen")]
public void ChannelPrefixes_RouteToTheirChannel(string raw, ChatChannelKind expectedChannel, string expectedText)
{
var parsed = ChatInputParser.Parse(raw, ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(expectedChannel, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal(expectedText, parsed.Value.Text);
}
// -- Edge cases: empty / whitespace / no-message --------------------
[Fact]
public void Empty_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse("", ChatChannelKind.Say, lastTellSender: null));
}
[Fact]
public void WhitespaceOnly_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse(" \t ", ChatChannelKind.Say, lastTellSender: null));
}
[Fact]
public void SayWithNoMessage_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse("/say", ChatChannelKind.Say, lastTellSender: null));
Assert.Null(ChatInputParser.Parse("/say ", ChatChannelKind.Say, lastTellSender: null));
}
[Fact]
public void TellWithNoTargetNoMessage_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse("/t", ChatChannelKind.Say, lastTellSender: null));
Assert.Null(ChatInputParser.Parse("/tell", ChatChannelKind.Say, lastTellSender: null));
}
[Fact]
public void TellWithTargetButNoMessage_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse("/t Bestie", ChatChannelKind.Say, lastTellSender: null));
Assert.Null(ChatInputParser.Parse("/tell Bestie ", ChatChannelKind.Say, lastTellSender: null));
}
[Fact]
public void ReplyWithNoMessage_ReturnsNull_EvenWithLastSender()
{
Assert.Null(ChatInputParser.Parse("/r", ChatChannelKind.Say, lastTellSender: "Bestie"));
Assert.Null(ChatInputParser.Parse("/r ", ChatChannelKind.Say, lastTellSender: "Bestie"));
}
[Fact]
public void ChannelPrefixWithNoMessage_ReturnsNull()
{
Assert.Null(ChatInputParser.Parse("/g", ChatChannelKind.Say, lastTellSender: null));
Assert.Null(ChatInputParser.Parse("/f ", ChatChannelKind.Say, lastTellSender: null));
Assert.Null(ChatInputParser.Parse("/a", ChatChannelKind.Say, lastTellSender: null));
}
// -- Unknown slash command: retail / ≡ @ equivalence. ACE's
// GameActionTalk only intercepts @-prefixed Talk on the wire, so
// the parser rewrites the unknown /-verb to its @ form for the
// server's CommandManager. (Deliberate divergence from holtburger's
// literal fall-through, which would speak the command out loud.)
[Fact]
public void UnknownSlashCommand_IsRewrittenToAtFormForServer()
{
var parsed = ChatInputParser.Parse("/xyz hello", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Say, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal("@xyz hello", parsed.Value.Text);
}
[Theory]
[InlineData("/ci 629", "@ci 629")] // ACE admin: create inventory item
[InlineData("/tele holtburg", "@tele holtburg")] // ACE admin: teleport
[InlineData("@ci 629", "@ci 629")] // @ form already server-ready — untouched
[InlineData("@acehelp", "@acehelp")]
public void ServerCommandVerbs_ReachTheWireInAtForm(string input, string expectedText)
{
var parsed = ChatInputParser.Parse(input, ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Say, parsed!.Value.Channel);
Assert.Equal(expectedText, parsed.Value.Text);
}
[Fact]
public void SlashWithoutLetterVerb_StaysLiteralAtParseLevel()
{
// "/ hello" and "//shrug" have no letter verb after the slash, so
// the pure Parse function leaves them untouched. In the real
// submit flows they never reach the wire: ChatCommandRouter's
// degenerate-prefix guard refuses them locally (Phase J Tier 4 —
// /-prefixed text must never broadcast as speech).
Assert.Equal("/ hello", ChatInputParser.Parse("/ hello", ChatChannelKind.Say, lastTellSender: null)!.Value.Text);
Assert.Equal("//shrug", ChatInputParser.Parse("//shrug", ChatChannelKind.Say, lastTellSender: null)!.Value.Text);
}
// -- Default-channel parameter is honoured when no prefix is given --
[Fact]
public void NoPrefix_HonoursAlternateDefaultChannel()
{
// If the panel ever defaults to e.g. Fellowship channel input,
// the parser must use that for unprefixed text.
var parsed = ChatInputParser.Parse("hi gang", ChatChannelKind.Fellowship, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Fellowship, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal("hi gang", parsed.Value.Text);
}
// -- The verb itself must be exact: prefix-of-other-word doesn't count --
[Fact]
public void PrefixSubstring_IsNotAVerbMatch()
{
// Phase J added long-form aliases (/general, /allegiance,
// /patron, etc.). The exact-token rule still applies — a
// verb prefix that ISN'T one of the listed aliases is NOT a
// client verb; it routes to the server in @ form like any
// other unknown verb (retail / ≡ @).
var parsed = ChatInputParser.Parse("/genio public", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(ChatChannelKind.Say, parsed!.Value.Channel);
Assert.Equal("@genio public", parsed.Value.Text);
}
[Theory]
[InlineData("/g", true)]
[InlineData("/say", true)]
[InlineData("/tell", true)]
[InlineData("/retell", true)]
[InlineData("/rt", true)]
[InlineData("/rp", true)] // reply alias now, not Roleplay (Tier 1 fix #2)
[InlineData("/guild", true)]
// Campaign CH slice CH4 (2026-08-09): "/allegiance"/"/lookingforgroup"
// are DELETED from ChatInputParser — "allegiance" is now
// RetailClientCommandCatalog's management command (Tier 1 fix #3);
// "lookingforgroup" was never a retail verb (doc §4 removal list).
[InlineData("/allegiance", false)]
[InlineData("/lookingforgroup", false)]
[InlineData("/role", false)] // acdream invention, deleted
[InlineData("/cv", false)] // acdream invention, deleted
[InlineData("/genio", false)]
[InlineData("/ls", false)]
[InlineData("/foo", false)]
[InlineData("/", false)]
public void IsKnownVerb_ChecksAgainstAliasTables(string verb, bool expected)
{
Assert.Equal(expected, ChatInputParser.IsKnownVerb(verb));
}
[Fact]
public void IsKnownVerb_TrimsTrailingComma()
{
// Campaign CH slice CH4 (2026-08-09), Tier 1 fix #5: retail's
// DoCommand right-trims ',' off the verb before lookup — the verb
// TOKEN itself ("/f,", as GetVerbToken would extract from "/f, hi").
Assert.True(ChatInputParser.IsKnownVerb("/f,"));
Assert.True(ChatInputParser.IsKnownVerb("/f"));
}
[Fact]
public void CommaTrimmedVerb_ParsesTheSameAsWithoutComma()
{
// "/f, hi" == "/f hi" end to end through Parse.
var withComma = ChatInputParser.Parse("/f, hi", ChatChannelKind.Say, lastTellSender: null);
var withoutComma = ChatInputParser.Parse("/f hi", ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(withComma);
Assert.NotNull(withoutComma);
Assert.Equal(withoutComma!.Value.Channel, withComma!.Value.Channel);
Assert.Equal(withoutComma.Value.Text, withComma.Value.Text);
Assert.Equal(ChatChannelKind.Fellowship, withComma.Value.Channel);
Assert.Equal("hi", withComma.Value.Text);
}
[Theory]
[InlineData("/g hello", "/g")]
[InlineData("/tell Bob hi", "/tell")]
[InlineData("/foo", "/foo")]
[InlineData("/", "/")]
public void GetVerbToken_PullsFirstWhitespaceToken(string command, string expected)
{
Assert.Equal(expected, ChatInputParser.GetVerbToken(command));
}
[Theory]
[InlineData("/general what's the deal", ChatChannelKind.General, "what's the deal")]
[InlineData("/guild recall", ChatChannelKind.Allegiance, "recall")]
[InlineData("/patron need help", ChatChannelKind.Patron, "need help")]
[InlineData("/vassals listen up", ChatChannelKind.Vassals, "listen up")]
[InlineData("/monarch heads up", ChatChannelKind.Monarch, "heads up")]
[InlineData("/covassals tax season", ChatChannelKind.CoVassals, "tax season")]
[InlineData("/fellowship buff time", ChatChannelKind.Fellowship, "buff time")]
[InlineData("/fellow buff time", ChatChannelKind.Fellowship, "buff time")]
[InlineData("/fellows buff time", ChatChannelKind.Fellowship, "buff time")]
[InlineData("/group buff time", ChatChannelKind.Fellowship, "buff time")]
[InlineData("/party buff time", ChatChannelKind.Fellowship, "buff time")]
[InlineData("/clfg hunt invite", ChatChannelKind.Lfg, "hunt invite")]
[InlineData("/roleplay walk-up", ChatChannelKind.Roleplay, "walk-up")]
[InlineData("/crp walk-up", ChatChannelKind.Roleplay, "walk-up")]
public void LongFormAliases_RouteToTheirChannel(string raw, ChatChannelKind expected, string text)
{
// Phase J: retail muscle memory uses long forms ("/patron"
// not just "/p"). Filed after a 2026-04-25 live test where
// "/patron hello" fell through as /say with the literal
// slash-prefixed text.
var parsed = ChatInputParser.Parse(raw, ChatChannelKind.Say, lastTellSender: null);
Assert.NotNull(parsed);
Assert.Equal(expected, parsed!.Value.Channel);
Assert.Null(parsed.Value.TargetName);
Assert.Equal(text, parsed.Value.Text);
}
// ── Issue #363: IsBareRegisteredChannelVerb / IsReplyMissingLastTeller ──
[Theory]
[InlineData("/g")]
[InlineData("/f")]
[InlineData("/fellow")]
[InlineData("/fellows")]
[InlineData("/fellowship")]
[InlineData("/group")]
[InlineData("/party")]
[InlineData("/a")]
[InlineData("/guild")]
[InlineData("/gu")]
[InlineData("/ab")]
[InlineData("/m")]
[InlineData("/monarch")]
[InlineData("/p")]
[InlineData("/patron")]
[InlineData("/v")]
[InlineData("/vassal")]
[InlineData("/vassals")]
[InlineData("/c")]
[InlineData("/covassal")]
[InlineData("/covassals")]
[InlineData("/co-vassals")]
public void IsBareRegisteredChannelVerb_TrueForEveryLegacyChannelAlias(string verb)
{
Assert.True(ChatInputParser.IsBareRegisteredChannelVerb(verb));
}
[Theory]
[InlineData("/general")]
[InlineData("/cg")]
[InlineData("/lfg")]
[InlineData("/clfg")]
[InlineData("/trade")]
[InlineData("/ct")]
[InlineData("/roleplay")]
[InlineData("/crp")]
[InlineData("/society")]
[InlineData("/soc")]
[InlineData("/olthoi")]
[InlineData("/o")]
public void IsBareRegisteredChannelVerb_FalseForTurbineOnlyChannels(string verb)
{
// The seven Turbine-only channels are never DoStupidChannelHack's
// clients (command-registry doc §2.3).
Assert.False(ChatInputParser.IsBareRegisteredChannelVerb(verb));
}
[Theory]
[InlineData("/g hi gang")]
[InlineData("/a hey")]
[InlineData("hello")]
[InlineData("/say hi")]
[InlineData("/r hi")]
public void IsBareRegisteredChannelVerb_FalseWithMessageOrNotAChannelVerb(string input)
{
Assert.False(ChatInputParser.IsBareRegisteredChannelVerb(input));
}
[Theory]
[InlineData("/r hi there")]
[InlineData("/reply hi there")]
[InlineData("/rp hi there")]
public void IsReplyMissingLastTeller_TrueWithMessageAndNoLastTeller(string input)
{
Assert.True(ChatInputParser.IsReplyMissingLastTeller(input, lastTellSender: null));
Assert.True(ChatInputParser.IsReplyMissingLastTeller(input, lastTellSender: ""));
}
[Fact]
public void IsReplyMissingLastTeller_FalseWhenLastTellerPresent()
{
Assert.False(ChatInputParser.IsReplyMissingLastTeller("/r hi there", lastTellSender: "Bestie"));
}
[Theory]
[InlineData("/r")]
[InlineData("/r ")]
[InlineData("/g hi gang")]
[InlineData("hello")]
public void IsReplyMissingLastTeller_FalseWithoutAMessageOrNotAReplyVerb(string input)
{
// Bare "/r" (no message at all) is a DIFFERENT retail branch
// (DoReply's own copy of the "you must specify text" string) and
// is deliberately out of scope for this predicate — see its doc
// comment.
Assert.False(ChatInputParser.IsReplyMissingLastTeller(input, lastTellSender: null));
}
}