test(mssql-json): add OpenAPI + GraphQL schema-discovery tests (Phase 3b)

Proves the 'JSON is treated as a normal string' contract at the schema-discovery layer, complementing the merged REST round-trip tests (#3720).

- JsonTypeSchemaTests (T008): the profiles.metadata json column is exposed in the OpenAPI document as type:string, nullable, with no bespoke format.

- MsSqlGraphQLJsonSchemaTests (T009): GraphQL introspection reports Profile.metadata as the built-in nullable String scalar (no custom JSON scalar).

MCP describe_entities (T010) is intentionally omitted: describe_entities projects only config field name/description, not DB column data types, so there is no JSON-specific behavior to assert there.

Author: souvikghosh04

src/Service.Tests/OpenApiDocumentor/JsonTypeSchemaTests.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Azure.DataApiBuilder.Config.ObjectModel;
+using Microsoft.OpenApi.Models;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Azure.DataApiBuilder.Service.Tests.OpenApiIntegration
+{
+    /// <summary>
+    /// Validates how a SQL Server 2025 native <c>json</c> column is surfaced in the generated
+    /// OpenAPI document. DAB does nothing special for a JSON column - it is treated as a normal
+    /// <c>string</c>, so it must be described with <c>type: string</c>, no custom <c>format</c>,
+    /// and honoring the column's nullability. This is the schema-discovery counterpart to the
+    /// REST round-trip coverage in
+    /// <see cref="SqlTests.RestApiTests.MsSqlRestJsonTypesTests"/>.
+    /// NOTE: The native JSON data type requires SQL Server 2025 / Azure SQL.
+    /// </summary>
+    [TestCategory(TestCategory.MSSQL)]
+    [TestClass]
+    public class JsonTypeSchemaTests
+    {
+        private const string CONFIG_FILE = "json-type-openapi-config.MsSql.json";
+        private const string DB_ENV = TestCategory.MSSQL;
+
+        /// <summary>
+        /// The <c>profiles.metadata</c> (json, nullable) column must appear in the OpenAPI schema as
+        /// a plain nullable string with no format - proving JSON is not given a bespoke scalar/format.
+        /// </summary>
+        [TestMethod]
+        public async Task JsonColumn_IsDescribedAsNullableStringWithoutFormat()
+        {
+            OpenApiDocument doc = await GenerateProfileDocumentAsync();
+
+            Assert.IsTrue(doc.Components.Schemas.ContainsKey("Profile"), "Schema should exist for the Profile entity.");
+
+            OpenApiSchema profileSchema = doc.Components.Schemas["Profile"];
+            Assert.IsTrue(profileSchema.Properties.ContainsKey("metadata"), "The json 'metadata' column should be present in the schema.");
+
+            OpenApiSchema metadataSchema = profileSchema.Properties["metadata"];
+            Assert.AreEqual("string", metadataSchema.Type, "A json column must be described as a plain string (treated like any string column).");
+            Assert.IsTrue(string.IsNullOrEmpty(metadataSchema.Format), "A json column must not carry a bespoke OpenAPI format.");
+            Assert.IsTrue(metadataSchema.Nullable, "The nullable json column must be described as nullable.");
+        }
+
+        /// <summary>
+        /// Builds an OpenAPI document for a Profile entity sourced from the <c>profiles</c> table,
+        /// with REST + GraphQL enabled and anonymous/authenticated CRUD permissions.
+        /// </summary>
+        private static async Task<OpenApiDocument> GenerateProfileDocumentAsync()
+        {
+            Entity entity = new(
+                Source: new("profiles", EntitySourceType.Table, null, null),
+                Fields: null,
+                GraphQL: new("Profile", "Profiles", true),
+                Rest: new(EntityRestOptions.DEFAULT_SUPPORTED_VERBS),
+                Permissions: OpenApiTestBootstrap.CreateBasicPermissions(),
+                Mappings: null,
+                Relationships: null);
+
+            RuntimeEntities entities = new(new Dictionary<string, Entity> { { "Profile", entity } });
+            return await OpenApiTestBootstrap.GenerateOpenApiDocumentAsync(entities, CONFIG_FILE, DB_ENV);
+        }
+    }
+}

src/Service.Tests/SqlTests/GraphQLQueryTests/MsSqlGraphQLJsonSchemaTests.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Azure.DataApiBuilder.Service.Tests.SqlTests.GraphQLQueryTests
+{
+    /// <summary>
+    /// GraphQL schema-discovery (introspection) tests for a SQL Server 2025 native <c>json</c> column.
+    /// DAB does nothing special for a JSON column - it is treated as a normal <c>string</c>, so the
+    /// GraphQL schema must expose it using the built-in <c>String</c> scalar (no bespoke JSON scalar),
+    /// honoring the column's nullability. This is the GraphQL counterpart to the REST/OpenAPI coverage
+    /// in <see cref="RestApiTests.MsSqlRestJsonTypesTests"/> and <c>JsonTypeSchemaTests</c>.
+    /// NOTE: The native JSON data type requires SQL Server 2025 / Azure SQL.
+    /// </summary>
+    [TestClass, TestCategory(TestCategory.MSSQL)]
+    public class MsSqlGraphQLJsonSchemaTests : SqlTestBase
+    {
+        [ClassInitialize]
+        public static async Task SetupAsync(TestContext context)
+        {
+            DatabaseEngine = TestCategory.MSSQL;
+            await InitializeTestFixture();
+        }
+
+        /// <summary>
+        /// Introspecting the Profile type must report its json-backed <c>metadata</c> field as the
+        /// built-in nullable <c>String</c> scalar - proving JSON gets no custom scalar in the schema.
+        /// </summary>
+        [TestMethod]
+        public async Task JsonColumn_IsIntrospectedAsBuiltInStringScalar()
+        {
+            string introspectionQuery = @"{
+                __type(name: ""Profile"") {
+                    name
+                    fields {
+                        name
+                        type { kind name ofType { kind name } }
+                    }
+                }
+            }";
+
+            JsonElement type = await ExecuteGraphQLRequestAsync(introspectionQuery, "__type", isAuthenticated: false);
+
+            Assert.AreEqual("Profile", type.GetProperty("name").GetString(), "Introspection should resolve the Profile GraphQL type.");
+
+            JsonElement metadataField = type.GetProperty("fields").EnumerateArray()
+                .Single(f => f.GetProperty("name").GetString() == "metadata");
+
+            // A nullable column surfaces as the bare scalar (no NON_NULL wrapper), so type.kind/name
+            // describe the scalar directly.
+            JsonElement metadataType = metadataField.GetProperty("type");
+            Assert.AreEqual("SCALAR", metadataType.GetProperty("kind").GetString(), "A json column must map to a scalar, not a custom object/scalar type.");
+            Assert.AreEqual("String", metadataType.GetProperty("name").GetString(), "A json column must use the built-in String scalar (no bespoke JSON scalar).");
+        }
+    }
+}