Add coverage for JSON schema and protobuf extensions

Author: jwils

elasticgraph-json_schema/spec/unit/elastic_graph/json_schema/schema_definition/api_extension_spec.rb

@@ -11,6 +11,82 @@
 module ElasticGraph
   module JsonSchema
     module SchemaDefinition
+      RSpec.describe APIExtension do
+        def build_api_with_extension
+          state = ::Struct.new(
+            :json_schema_version,
+            :json_schema_version_setter_location,
+            :allow_omitted_json_schema_fields,
+            :allow_extra_json_schema_fields,
+            keyword_init: true
+          ).new
+
+          factory = ::Object.new
+
+          api = ::Object.new
+          api.instance_variable_set(:@state, state)
+          api.define_singleton_method(:factory) { factory }
+          api.extend(APIExtension)
+
+          [api, state, factory]
+        end
+
+        it "extends the api factory with JSON schema factory behavior" do
+          _api, _state, factory = build_api_with_extension
+
+          expect(factory).to be_a(FactoryExtension)
+        end
+
+        it "stores the JSON schema version and its setter location" do
+          api, state, = build_api_with_extension
+
+          expect(api.json_schema_version(3)).to eq(nil)
+          expect(state.json_schema_version).to eq(3)
+          expect(state.json_schema_version_setter_location).to be_a(::Thread::Backtrace::Location)
+        end
+
+        it "rejects invalid JSON schema versions" do
+          api, = build_api_with_extension
+
+          expect {
+            api.json_schema_version(0)
+          }.to raise_error(Errors::SchemaError, /must be a positive integer/)
+
+          expect {
+            api.json_schema_version("3")
+          }.to raise_error(Errors::SchemaError, /must be a positive integer/)
+        end
+
+        it "rejects setting the JSON schema version more than once" do
+          api, = build_api_with_extension
+          api.json_schema_version(1)
+
+          expect {
+            api.json_schema_version(2)
+          }.to raise_error(Errors::SchemaError, /can only be set once/)
+        end
+
+        it "stores JSON schema strictness settings" do
+          api, state, = build_api_with_extension
+
+          expect(api.json_schema_strictness(allow_omitted_fields: true, allow_extra_fields: false)).to eq(nil)
+          expect(state.allow_omitted_json_schema_fields).to eq(true)
+          expect(state.allow_extra_json_schema_fields).to eq(false)
+        end
+
+        it "validates JSON schema strictness arguments" do
+          api, = build_api_with_extension
+
+          expect {
+            api.json_schema_strictness(allow_omitted_fields: :sometimes)
+          }.to raise_error(Errors::SchemaError, /allow_omitted_fields/)
+
+          expect {
+            api.json_schema_strictness(allow_extra_fields: :sometimes)
+          }.to raise_error(Errors::SchemaError, /allow_extra_fields/)
+        end
+      end
+
       RSpec.describe APIExtension, :json_schema_schema do
         it "adds JSON schema generation and artifact dumping through schema definition extension hooks" do
           results = define_json_schema_schema(reload_schema_artifacts: true, json_schema_version: nil) do |schema|

elasticgraph-json_schema/spec/unit/elastic_graph/json_schema/schema_definition/factory_extension_spec.rb

@@ -0,0 +1,48 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/json_schema/schema_definition/factory_extension"
+
+module ElasticGraph
+  module JsonSchema
+    module SchemaDefinition
+      RSpec.describe FactoryExtension do
+        let(:factory_class) do
+          base_class = ::Class.new do
+            def new_results
+              ::Object.new
+            end
+
+            def new_schema_artifact_manager(*args, **kwargs)
+              @last_schema_artifact_manager_args = args
+              @last_schema_artifact_manager_kwargs = kwargs
+              ::Object.new
+            end
+
+            attr_reader :last_schema_artifact_manager_args, :last_schema_artifact_manager_kwargs
+          end
+
+          ::Class.new(base_class) do
+            prepend FactoryExtension
+          end
+        end
+
+        it "extends results and schema artifact managers with JSON schema behavior" do
+          factory = factory_class.new
+
+          expect(factory.new_results).to be_a(ResultsExtension)
+
+          manager = factory.new_schema_artifact_manager(:positional, key: "value")
+          expect(manager).to be_a(SchemaArtifactManagerExtension)
+          expect(factory.last_schema_artifact_manager_args).to eq([:positional])
+          expect(factory.last_schema_artifact_manager_kwargs).to eq({key: "value"})
+        end
+      end
+    end
+  end
+end

elasticgraph-json_schema/spec/unit/elastic_graph/json_schema/schema_definition/results_extension_spec.rb

@@ -0,0 +1,193 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/json_schema/schema_definition/results_extension"
+
+module ElasticGraph
+  module JsonSchema
+    module SchemaDefinition
+      FakeType = ::Struct.new(
+        :name,
+        :indexing_field_type,
+        :root_document_type_value,
+        :abstract_value,
+        :graphql_only_value,
+        keyword_init: true
+      ) do
+        def root_document_type?
+          root_document_type_value
+        end
+
+        def abstract?
+          abstract_value
+        end
+
+        def graphql_only?
+          graphql_only_value
+        end
+
+        def to_indexing_field_type
+          indexing_field_type
+        end
+      end
+
+      FakeIndexingFieldType = ::Struct.new(:json_schema, :field_metadata, keyword_init: true) do
+        def to_json_schema
+          json_schema
+        end
+
+        def json_schema_field_metadata_by_field_name
+          field_metadata
+        end
+      end
+
+      FakeMergedSchema = ::Struct.new(:json_schema_version, :json_schema, keyword_init: true)
+
+      RSpec.describe ResultsExtension do
+        def build_results(state:, derived_indexing_type_names: Set[])
+          ::Object.new.tap do |results|
+            results.extend(described_class)
+            results.define_singleton_method(:state) { state }
+            results.define_singleton_method(:derived_indexing_type_names) { derived_indexing_type_names }
+          end
+        end
+
+        it "builds the current public JSON schema, exposes metadata helpers, and memoizes merged schemas" do
+          widget_indexing_type = FakeIndexingFieldType.new(
+            json_schema: {"type" => "object"},
+            field_metadata: {"id" => {"name_in_index" => "id"}}
+          )
+
+          widget_type = FakeType.new(
+            name: "Widget",
+            indexing_field_type: widget_indexing_type,
+            root_document_type_value: true,
+            abstract_value: false,
+            graphql_only_value: false
+          )
+          derived_type = FakeType.new(
+            name: "DerivedWidget",
+            indexing_field_type: widget_indexing_type,
+            root_document_type_value: true,
+            abstract_value: false,
+            graphql_only_value: false
+          )
+          graphql_only_type = FakeType.new(
+            name: "GraphqlOnly",
+            indexing_field_type: widget_indexing_type,
+            root_document_type_value: false,
+            abstract_value: false,
+            graphql_only_value: true
+          )
+          query_type = FakeType.new(
+            name: "Query",
+            indexing_field_type: widget_indexing_type,
+            root_document_type_value: false,
+            abstract_value: false,
+            graphql_only_value: false
+          )
+
+          setter_location = instance_double(::Thread::Backtrace::Location)
+          state = ::Struct.new(
+            :json_schema_version,
+            :json_schema_version_setter_location,
+            :object_types_by_name,
+            :types_by_name,
+            keyword_init: true
+          ).new(
+            json_schema_version: 3,
+            json_schema_version_setter_location: setter_location,
+            object_types_by_name: {
+              "Widget" => widget_type,
+              "DerivedWidget" => derived_type
+            },
+            types_by_name: {
+              "Query" => query_type,
+              "Widget" => widget_type,
+              "DerivedWidget" => derived_type,
+              "GraphqlOnly" => graphql_only_type
+            }
+          )
+
+          results = build_results(state: state, derived_indexing_type_names: Set["DerivedWidget"])
+
+          merged_schema = FakeMergedSchema.new(
+            json_schema_version: 3,
+            json_schema: {"json_schema_version" => 3, "$defs" => {"Widget" => {"with_metadata" => true}}}
+          )
+          merger = instance_double(
+            ElasticGraph::SchemaDefinition::Indexing::JSONSchemaWithMetadata::Merger,
+            merge_metadata_into: merged_schema,
+            unused_deprecated_elements: [:unused]
+          )
+
+          expect(ElasticGraph::SchemaDefinition::Indexing::JSONSchemaWithMetadata::Merger).to receive(:new).with(results).once.and_return(merger)
+          expect(ElasticGraph::SchemaDefinition::Indexing::EventEnvelope).to receive(:json_schema).with(["Widget"], 3).once.and_return({"type" => "object"})
+
+          expect(results.available_json_schema_versions).to eq(Set[3])
+          expect(results.latest_json_schema_version).to eq(3)
+          expect(results.json_schema_version_setter_location).to be(setter_location)
+          expect(results.json_schema_field_metadata_by_type_and_field_name).to eq({"Widget" => {"id" => {"name_in_index" => "id"}}})
+          expect(results.current_public_json_schema).to include(
+            "$schema" => JSON_META_SCHEMA,
+            JSON_SCHEMA_VERSION_KEY => 3
+          )
+          expect(results.current_public_json_schema.fetch("$defs")).to include(
+            "ElasticGraphEventEnvelope" => {"type" => "object"},
+            "Widget" => {"type" => "object"}
+          )
+          expect(results.unused_deprecated_elements).to eq([:unused])
+          expect(results.json_schemas_for(3)).to eq({"json_schema_version" => 3, "$defs" => {"Widget" => {"with_metadata" => true}}})
+          expect(results.json_schemas_for(3)).to eq({"json_schema_version" => 3, "$defs" => {"Widget" => {"with_metadata" => true}}})
+        end
+
+        it "raises when the requested JSON schema version is unavailable" do
+          state = ::Struct.new(
+            :json_schema_version,
+            :json_schema_version_setter_location,
+            :object_types_by_name,
+            :types_by_name,
+            keyword_init: true
+          ).new(
+            json_schema_version: 3,
+            json_schema_version_setter_location: nil,
+            object_types_by_name: {},
+            types_by_name: {}
+          )
+
+          results = build_results(state: state)
+
+          expect {
+            results.json_schemas_for(2)
+          }.to raise_error(Errors::NotFoundError, /requested json schema version \(2\) is not available/)
+        end
+
+        it "raises when json_schema_version has not been configured" do
+          state = ::Struct.new(
+            :json_schema_version,
+            :json_schema_version_setter_location,
+            :object_types_by_name,
+            :types_by_name,
+            keyword_init: true
+          ).new(
+            json_schema_version: nil,
+            json_schema_version_setter_location: nil,
+            object_types_by_name: {},
+            types_by_name: {}
+          )
+
+          results = build_results(state: state)
+
+          expect {
+            results.current_public_json_schema
+          }.to raise_error(Errors::SchemaError, /`json_schema_version` must be specified/)
+        end
+      end
+    end
+  end
+end