ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.InboundAPI.Tests/ParameterValidatorTests.cs

using System.Text.Json;

namespace ZB.MOM.WW.ScadaBridge.InboundAPI.Tests;

/// <summary>
/// WP-2 / InboundAPI-M2.6: tests for parameter validation — type checking,
/// required fields, the extended type system, and RECURSIVE (nested Object /
/// List element) type validation with path-qualified errors.
///
/// <para>
/// Definitions are expressed as JSON Schema (the canonical persisted format
/// produced by the Central UI / migration). The validator also accepts the
/// legacy flat-array form; that backward-compat path is covered by the final
/// region.
/// </para>
/// </summary>
public class ParameterValidatorTests
{
    private static JsonElement Body(string json)
    {
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.Clone();
    }

    // ── No / empty definitions ────────────────────────────────────────────────

    [Fact]
    public void NoDefinitions_NoBody_ReturnsValid()
    {
        var result = ParameterValidator.Validate(null, null);
        Assert.True(result.IsValid);
        Assert.Empty(result.Parameters);
    }

    [Fact]
    public void EmptyObjectSchema_ReturnsValid()
    {
        var result = ParameterValidator.Validate(null, """{"type":"object","properties":{}}""");
        Assert.True(result.IsValid);
    }

    [Fact]
    public void EmptyLegacyArray_ReturnsValid()
    {
        var result = ParameterValidator.Validate(null, "[]");
        Assert.True(result.IsValid);
    }

    // ── Required / body shape ──────────────────────────────────────────────────

    [Fact]
    public void RequiredParameterMissing_ReturnsInvalid()
    {
        const string def = """{"type":"object","properties":{"value":{"type":"integer"}},"required":["value"]}""";

        var result = ParameterValidator.Validate(null, def);
        Assert.False(result.IsValid);
        Assert.Contains("Missing required parameter", result.ErrorMessage);
    }

    [Fact]
    public void BodyNotObject_ReturnsInvalid()
    {
        const string def = """{"type":"object","properties":{"value":{"type":"string"}},"required":["value"]}""";

        var result = ParameterValidator.Validate(Body("\"just a string\""), def);
        Assert.False(result.IsValid);
        Assert.Contains("must be a JSON object", result.ErrorMessage);
    }

    [Fact]
    public void OptionalParameter_MissingBody_ReturnsValid()
    {
        const string def = """{"type":"object","properties":{"optional":{"type":"string"}}}""";

        var result = ParameterValidator.Validate(null, def);
        Assert.True(result.IsValid);
    }

    // ── Scalar coercion ────────────────────────────────────────────────────────

    [Theory]
    [InlineData("boolean", "true", true)]
    [InlineData("integer", "42", (long)42)]
    [InlineData("number", "3.14", 3.14)]
    [InlineData("string", "\"hello\"", "hello")]
    public void ValidTypeCoercion_Succeeds(string type, string jsonValue, object expected)
    {
        var def = "{\"type\":\"object\",\"properties\":{\"val\":{\"type\":\"" + type + "\"}},\"required\":[\"val\"]}";

        var result = ParameterValidator.Validate(Body($"{{\"val\": {jsonValue}}}"), def);
        Assert.True(result.IsValid);
        Assert.Equal(expected, result.Parameters["val"]);
    }

    [Fact]
    public void WrongScalarType_ReturnsInvalid()
    {
        const string def = """{"type":"object","properties":{"count":{"type":"integer"}},"required":["count"]}""";

        var result = ParameterValidator.Validate(Body("{\"count\": \"not a number\"}"), def);
        Assert.False(result.IsValid);
        Assert.Contains("'count'", result.ErrorMessage);
        Assert.Contains("Integer", result.ErrorMessage);
    }

    [Fact]
    public void UnknownType_ReturnsInvalid()
    {
        const string def = """{"type":"object","properties":{"val":{"type":"customtype"}},"required":["val"]}""";

        var result = ParameterValidator.Validate(Body("{\"val\": \"test\"}"), def);
        Assert.False(result.IsValid);
        Assert.Contains("unknown declared type", result.ErrorMessage);
    }

    // ── Object / List shape + materialization ──────────────────────────────────

    [Fact]
    public void ObjectType_NoDeclaredFields_ShapeOnly_Materialized()
    {
        const string def = """{"type":"object","properties":{"data":{"type":"object"}},"required":["data"]}""";

        var result = ParameterValidator.Validate(Body("{\"data\": {\"key\": \"value\"}}"), def);
        Assert.True(result.IsValid);
        Assert.IsType<Dictionary<string, object?>>(result.Parameters["data"]);
    }

    [Fact]
    public void ListType_NoDeclaredElement_ShapeOnly_Materialized()
    {
        const string def = """{"type":"object","properties":{"items":{"type":"array"}},"required":["items"]}""";

        var result = ParameterValidator.Validate(Body("{\"items\": [1, 2, 3]}"), def);
        Assert.True(result.IsValid);
        Assert.IsType<List<object?>>(result.Parameters["items"]);
    }

    // ── Undeclared / unexpected fields (rejected, recursively) ─────────────────

    [Fact]
    public void UnexpectedTopLevelField_ReturnsInvalid()
    {
        const string def = """{"type":"object","properties":{"value":{"type":"integer"}},"required":["value"]}""";

        // "valeu" is a typo for "value"; the caller must be told, not ignored.
        var result = ParameterValidator.Validate(Body("{\"value\": 1, \"valeu\": 2}"), def);

        Assert.False(result.IsValid);
        Assert.Contains("valeu", result.ErrorMessage);
        Assert.Contains("not a declared field", result.ErrorMessage);
    }

    [Fact]
    public void OnlyDeclaredFields_StillValid()
    {
        const string def = """{"type":"object","properties":{"value":{"type":"integer"}},"required":["value"]}""";

        var result = ParameterValidator.Validate(Body("{\"value\": 1}"), def);

        Assert.True(result.IsValid);
        Assert.Equal((long)1, result.Parameters["value"]);
    }

    [Fact]
    public void UndeclaredNestedField_ReturnsInvalid_PathQualified()
    {
        const string def = """
        {"type":"object","properties":{
            "order":{"type":"object","properties":{"id":{"type":"integer"}},"required":["id"]}
        },"required":["order"]}
        """;

        var result = ParameterValidator.Validate(
            Body("""{"order":{"id":1,"bogus":2}}"""), def);

        Assert.False(result.IsValid);
        Assert.Contains("order.bogus", result.ErrorMessage);
        Assert.Contains("not a declared field", result.ErrorMessage);
    }

    // ── Nested validation: the M2.6 core ───────────────────────────────────────

    private const string NestedDef = """
    {
      "type":"object",
      "properties":{
        "order":{
          "type":"object",
          "properties":{
            "id":{"type":"integer"},
            "customer":{
              "type":"object",
              "properties":{"name":{"type":"string"},"vip":{"type":"boolean"}},
              "required":["name"]
            },
            "items":{
              "type":"array",
              "items":{
                "type":"object",
                "properties":{"sku":{"type":"string"},"quantity":{"type":"integer"}},
                "required":["sku","quantity"]
              }
            }
          },
          "required":["id","customer","items"]
        }
      },
      "required":["order"]
    }
    """;

    [Fact]
    public void ValidNestedPayload_Passes()
    {
        const string body = """
        {"order":{
            "id":7,
            "customer":{"name":"Acme","vip":true},
            "items":[
                {"sku":"A1","quantity":3},
                {"sku":"B2","quantity":1}
            ]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void WrongScalarTwoLevelsDeep_ReturnsInvalid_WithExactPath()
    {
        // order.customer.vip declared boolean, given a string.
        const string body = """
        {"order":{
            "id":7,
            "customer":{"name":"Acme","vip":"yes"},
            "items":[]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.False(result.IsValid);
        Assert.Contains("'order.customer.vip'", result.ErrorMessage);
        Assert.Contains("Boolean", result.ErrorMessage);
    }

    [Fact]
    public void WrongScalarInsideListElement_ReturnsInvalid_WithElementIndexInPath()
    {
        // order.items[1].quantity declared integer, given a string.
        const string body = """
        {"order":{
            "id":7,
            "customer":{"name":"Acme"},
            "items":[
                {"sku":"A1","quantity":3},
                {"sku":"B2","quantity":"lots"}
            ]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.False(result.IsValid);
        Assert.Contains("'order.items[1].quantity'", result.ErrorMessage);
        Assert.Contains("Integer", result.ErrorMessage);
    }

    [Fact]
    public void ListElementWrongShape_ReturnsInvalid_WithElementIndexInPath()
    {
        // order.items[0] declared object, given a scalar.
        const string body = """
        {"order":{
            "id":7,
            "customer":{"name":"Acme"},
            "items":[ 42 ]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.False(result.IsValid);
        Assert.Contains("'order.items[0]'", result.ErrorMessage);
        Assert.Contains("Object", result.ErrorMessage);
    }

    [Fact]
    public void MissingRequiredNestedField_ReturnsInvalid_PathQualified()
    {
        // order.customer.name is required but absent.
        const string body = """
        {"order":{
            "id":7,
            "customer":{"vip":false},
            "items":[]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.False(result.IsValid);
        Assert.Contains("missing required field", result.ErrorMessage);
        Assert.Contains("'order.customer.name'", result.ErrorMessage);
    }

    // ── Empty / null edge cases ────────────────────────────────────────────────

    [Fact]
    public void EmptyList_AgainstTypedElement_Passes()
    {
        const string body = """
        {"order":{"id":7,"customer":{"name":"Acme"},"items":[]}}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void NullForOptionalNestedScalar_Passes()
    {
        // order.customer.vip is optional; explicit null is accepted.
        const string body = """
        {"order":{
            "id":7,
            "customer":{"name":"Acme","vip":null},
            "items":[]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void NullForRequiredNestedScalar_Passes()
    {
        // A PRESENT-but-null required field satisfies the type — only ABSENCE
        // of a required field is an error (consistent with return-side policy).
        const string body = """
        {"order":{
            "id":null,
            "customer":{"name":"Acme"},
            "items":[]
        }}
        """;

        var result = ParameterValidator.Validate(Body(body), NestedDef);
        Assert.True(result.IsValid);
    }

    // ── Legacy flat-array backward-compat ──────────────────────────────────────

    [Fact]
    public void LegacyFlatArrayDefinition_StillAccepted()
    {
        const string def = """[{"name":"count","type":"Integer","required":true}]""";

        var ok = ParameterValidator.Validate(Body("{\"count\":5}"), def);
        Assert.True(ok.IsValid);
        Assert.Equal((long)5, ok.Parameters["count"]);

        var bad = ParameterValidator.Validate(Body("{\"count\":\"nope\"}"), def);
        Assert.False(bad.IsValid);
        Assert.Contains("'count'", bad.ErrorMessage);
    }
}