YKanBan/YKanBan.Tests/Search/SearchQueryParserTests.cs

using YKanBan.Search;

namespace YKanBan.Tests.Search;

/// <summary>
/// Tests for the search parser: the full grammar branches plus the strict
/// failure behavior (malformed input always throws
/// <see cref="SearchSyntaxException"/>).
/// </summary>
[TestClass]
public class SearchQueryParserTests {
    /// <summary>
    /// Parses and asserts structural equality against the expected AST.
    /// </summary>
    /// <param name="expected">The expected AST.</param>
    /// <param name="text">The search text.</param>
    private static void AssertParsesTo(SearchNode expected, string text) {
        SearchNode? parsed = SearchQueryParser.Parse(text);
        Assert.IsNotNull(parsed, $"Blank-looking input: '{text}'.");
        Assert.AreEqual(expected, parsed, SearchNodeComparer.Instance);
    }

    /// <summary>
    /// Asserts that the input violates the grammar.
    /// </summary>
    /// <param name="text">The search text.</param>
    private static void AssertSyntaxError(string text) {
        Assert.ThrowsExactly<SearchSyntaxException>(() => SearchQueryParser.Parse(text));
    }

    #region Successful parses

    [TestMethod]
    public void BlankInputReturnsNull() {
        Assert.IsNull(SearchQueryParser.Parse(string.Empty));
        Assert.IsNull(SearchQueryParser.Parse("   "));
    }

    [TestMethod]
    public void SingleWordIsFreeText() {
        AssertParsesTo(new SearchNode.FreeText("login"), "login");
    }

    [TestMethod]
    public void AdjacentWordsAreImplicitAnd() {
        AssertParsesTo(
            new SearchNode.And([new SearchNode.FreeText("fix"), new SearchNode.FreeText("login")]),
            "fix login");
    }

    [TestMethod]
    public void ExplicitAndKeyword() {
        AssertParsesTo(
            new SearchNode.And([new SearchNode.FreeText("a"), new SearchNode.FreeText("b")]),
            "a AND b");
    }

    [TestMethod]
    public void OrKeyword() {
        AssertParsesTo(
            new SearchNode.Or([new SearchNode.FreeText("a"), new SearchNode.FreeText("b")]),
            "a OR b");
    }

    [TestMethod]
    public void ImplicitAndBindsTighterThanOr() {
        AssertParsesTo(
            new SearchNode.Or([
                new SearchNode.And([new SearchNode.FreeText("a"), new SearchNode.FreeText("b")]),
                new SearchNode.FreeText("c")]),
            "a b OR c");
    }

    [TestMethod]
    public void ParenthesesForceGrouping() {
        AssertParsesTo(
            new SearchNode.And([
                new SearchNode.FreeText("a"),
                new SearchNode.Or([new SearchNode.FreeText("b"), new SearchNode.FreeText("c")])]),
            "a (b OR c)");
    }

    [TestMethod]
    public void NestedParenthesesCollapse() {
        AssertParsesTo(
            new SearchNode.Or([new SearchNode.FreeText("a"), new SearchNode.FreeText("b")]),
            "((a OR b))");
    }

    [TestMethod]
    public void LowercaseKeywordsArePlainWords() {
        AssertParsesTo(
            new SearchNode.And([
                new SearchNode.FreeText("a"),
                new SearchNode.FreeText("and"),
                new SearchNode.FreeText("or"),
                new SearchNode.FreeText("b")]),
            "a and or b");
    }

    [TestMethod]
    public void PhraseIsFreeText() {
        AssertParsesTo(new SearchNode.FreeText("hello world"), "\"hello world\"");
    }

    [TestMethod]
    public void QuotedOperatorKeywordIsFreeText() {
        // A quoted AND/OR is literal text, not an operator.
        AssertParsesTo(new SearchNode.FreeText("AND"), "\"AND\"");
        AssertParsesTo(
            new SearchNode.And([new SearchNode.FreeText("a"), new SearchNode.FreeText("OR")]),
            "a \"OR\"");
    }

    [TestMethod]
    public void PhraseSupportsEscapes() {
        // Escaped quote and escaped backslash.
        AssertParsesTo(new SearchNode.FreeText("a\"b"), "\"a\\\"b\"");
        AssertParsesTo(new SearchNode.FreeText("a\\b"), "\"a\\\\b\"");
    }

    [TestMethod]
    public void TagQualifier() {
        AssertParsesTo(new SearchNode.TagName("bug"), "tag:bug");
    }

    [TestMethod]
    public void TagQualifierAcceptsPhraseValue() {
        AssertParsesTo(new SearchNode.TagName("a b"), "tag:\"a b\"");
    }

    [TestMethod]
    public void QualifierValueMayContainColons() {
        AssertParsesTo(new SearchNode.TagName("a:b"), "tag:a:b");
    }

    [TestMethod]
    public void TitleAndContentQualifiers() {
        AssertParsesTo(new SearchNode.FieldText(SearchField.Title, "foo"), "title:foo");
        AssertParsesTo(new SearchNode.FieldText(SearchField.Content, "foo"), "content:foo");
    }

    [TestMethod]
    public void ColumnQualifierAcceptsPhraseValue() {
        AssertParsesTo(new SearchNode.ColumnTitle("To Do"), "column:\"To Do\"");
    }

    [TestMethod]
    public void IdQualifierParsesNumber() {
        AssertParsesTo(new SearchNode.CardId(42), "id:42");
        AssertParsesTo(new SearchNode.CardId(12), "id:\"12\"");
    }

    [TestMethod]
    public void ColonWithoutKeyPrefixIsFreeText() {
        AssertParsesTo(new SearchNode.FreeText(":foo"), ":foo");
    }

    #endregion

    #region Strict failures

    [TestMethod]
    public void UnterminatedPhraseIsAnError() {
        AssertSyntaxError("\"abc def");
    }

    [TestMethod]
    public void TrailingUnterminatedPhraseIsAnError() {
        AssertSyntaxError("a \"abc");
    }

    [TestMethod]
    public void InvalidEscapeInPhraseIsAnError() {
        // A bare backslash (not followed by a quote or another backslash) is invalid.
        AssertSyntaxError("\"a\\b\"");
    }

    [TestMethod]
    public void InvalidEscapeInQualifierPhraseIsAnError() {
        AssertSyntaxError("tag:\"a\\x\"");
    }

    [TestMethod]
    public void UnbalancedOpenParenIsAnError() {
        AssertSyntaxError("(a");
    }

    [TestMethod]
    public void StrayCloseParenIsAnError() {
        AssertSyntaxError("a)");
    }

    [TestMethod]
    public void EmptyParensAreAnError() {
        AssertSyntaxError("()");
    }

    [TestMethod]
    public void DanglingOrIsAnError() {
        AssertSyntaxError("a OR");
    }

    [TestMethod]
    public void DanglingAndIsAnError() {
        AssertSyntaxError("a AND");
    }

    [TestMethod]
    public void LeadingAndIsAnError() {
        AssertSyntaxError("AND a");
    }

    [TestMethod]
    public void OperatorAtOperandPositionIsAnError() {
        AssertSyntaxError("a AND OR b");
    }

    [TestMethod]
    public void QualifierWithoutValueIsAnError() {
        AssertSyntaxError("tag:");
    }

    [TestMethod]
    public void SpacedQualifierValueIsAnError() {
        AssertSyntaxError("tag: bug");
    }

    [TestMethod]
    public void NonNumericIdIsAnError() {
        AssertSyntaxError("id:12x");
    }

    [TestMethod]
    public void UnknownQualifierKeyIsAnError() {
        AssertSyntaxError("foo:bar");
    }

    [TestMethod]
    public void QualifierKeysAreCaseSensitive() {
        // "Tag" is a key-like prefix but not the known lowercase "tag", so it is unknown.
        AssertSyntaxError("Tag:x");
    }

    [TestMethod]
    public void SyntaxErrorCarriesDescriptiveMessage() {
        SearchSyntaxException exception = Assert.ThrowsExactly<SearchSyntaxException>(
            () => SearchQueryParser.Parse("a AND"));
        Assert.IsFalse(string.IsNullOrEmpty(exception.Message));
    }

    #endregion
}