json_matchers 0.9.0 → 0.10.0

data/lib/json_matchers/payload.rb

@@ -4,6 +4,10 @@ module JsonMatchers
       @payload = extract_json_string(payload)
     end
 
+    def as_json
+      JSON.parse(payload)
+    end
+
     def to_s
       payload
     end

data/lib/json_matchers/rspec.rb

@@ -5,20 +5,8 @@ module JsonMatchers
   self.schema_root = File.join("spec", "support", "api", "schemas")
 end
 
-RSpec::Matchers.define :match_json_schema do |schema_name, **options|
-  if options.present?
-    warn <<-WARN
-DEPRECATION:
-
-  After `json_matchers@0.9.x`, calls to `match_json_schema` and
-  `match_response_schema` will no longer accept options.
-
-  See https://github.com/thoughtbot/json_matchers/pull/31 for more information.
-
-WARN
-  end
-
-  assertion = JsonMatchers::Assertion.new(schema_name.to_s, options)
+RSpec::Matchers.define :match_json_schema do |schema_name|
+  assertion = JsonMatchers::Assertion.new(schema_name.to_s)
 
   match do |json|
     assertion.valid?(json)

data/lib/json_matchers/validator.rb

@@ -1,37 +1,34 @@
-require "json-schema"
+require "json_matchers/parser"
 
 module JsonMatchers
   class Validator
-    def initialize(options:, payload:, schema_path:)
-      @options = options.dup
-      @payload = payload
-      @schema_path = schema_path.to_s
+    def initialize(document_store:, schema_path:)
+      @document_store = document_store
+      @schema_path = schema_path
     end
 
-    def validate!
-      if recording_errors?
-        validate_recording_errors
-      else
-        validate
-      end
+    def validate(payload)
+      json_schema.validate!(payload.as_json, fail_fast: true)
+
+      []
+    rescue JsonSchema::Error => error
+      [error.message]
     end
 
     private
 
-    attr_reader :options, :payload, :schema_path
+    attr_reader :document_store, :schema_path
 
-    def recording_errors?
-      options.fetch(:record_errors, false)
+    def json_schema
+      @json_schema ||= build_json_schema_with_expanded_references
     end
 
-    def validate_recording_errors
-      JSON::Validator.fully_validate(schema_path, payload, options)
-    end
+    def build_json_schema_with_expanded_references
+      json_schema = Parser.new(schema_path).parse
 
-    def validate
-      JSON::Validator.validate!(schema_path, payload, options)
+      json_schema.expand_references!(store: document_store)
 
-      []
+      json_schema
     end
   end
 end

data/lib/json_matchers/version.rb

@@ -1,3 +1,3 @@
 module JsonMatchers
-  VERSION = "0.9.0".freeze
+  VERSION = "0.10.0".freeze
 end

data/spec/factories.rb

@@ -6,12 +6,12 @@ FactoryBot.define do
   factory :response, class: FakeResponse do
     skip_create
 
-    trait :object do
-      body { { "id": 1 } }
+    trait :location do
+      body { { "latitude": 1, "longitude": 1 } }
     end
 
-    trait :invalid_object do
-      body { { "id": "1" } }
+    trait :invalid_location do
+      body { { "latitude": "1", "longitude": "1" } }
     end
 
     initialize_with do
@@ -24,29 +24,32 @@ FactoryBot.define do
   end
 
   factory :schema, class: FakeSchema do
-    skip_create
-
     sequence(:name) { |n| "json_schema-#{n}" }
 
     trait :invalid do
       json { "" }
     end
 
-    trait :object do
+    trait :location do
       json do
         {
+          "id": "file:/#{name}.json#",
+          "description": "An object containing some #{name} data",
           "type": "object",
-          "required": [
-            "id",
-          ],
+          "required": ["latitude", "longitude"],
           "properties": {
-            "id": { "type": "number" },
+            "latitude": {
+              "type": "number",
+            },
+            "longitude": {
+              "type": "number",
+            },
           },
           "additionalProperties": false,
         }
       end
     end
-    trait(:objects) { object }
+    trait(:locations) { location }
 
     trait :array_of do
       initialize_with do
@@ -60,17 +63,49 @@ FactoryBot.define do
       end
     end
 
-    trait :referencing_objects do
-      association :items, factory: [:schema, :object]
+    trait :referencing_locations do
+      association :items, factory: [:schema, :location]
 
       initialize_with do
         FakeSchema.new(name, {
+          "$schema": "https://json-schema.org/draft-04/schema#",
           "type": "array",
-          "items": { "$ref": "#{items.name}.json" },
+          "items": { "$ref": "file:/#{items.name}.json#" },
         })
       end
     end
 
+    trait :referencing_definitions do
+      association :items, factory: [:schema, :location], name: "location"
+      association :example, factory: [:response, :location]
+
+      transient do
+        plural { items.name.pluralize }
+      end
+
+      json do
+        {
+          "$schema": "https://json-schema.org/draft-04/schema#",
+          "id": "file:/#{name}.json#",
+          "type": "object",
+          "definitions": {
+            plural => {
+              "type": "array",
+              "items": { "$ref": "file:/#{items.name}.json#" },
+              "description": "A collection of #{plural}",
+              "example": example,
+            },
+          },
+          "required": [plural],
+          "properties": {
+            plural => {
+              "$ref": "#/definitions/#{plural}",
+            },
+          },
+        }
+      end
+    end
+
     initialize_with do
       schema_body_as_json = attributes.fetch(:json, nil)
       schema_body = attributes.except(:json, :name)
@@ -78,10 +113,11 @@ FactoryBot.define do
       FakeSchema.new(name, schema_body_as_json || schema_body)
     end
 
-    after :create do |schema|
-      path = File.join(JsonMatchers.schema_root, "#{schema.name}.json")
+    to_create do |schema|
+      path = JsonMatchers.path_to_schema(schema.name)
       payload = JsonMatchers::Payload.new(schema.json)
 
+      path.dirname.mkpath
       IO.write(path, payload)
     end
   end

data/spec/json_matchers/match_json_schema_spec.rb

@@ -20,51 +20,59 @@ describe JsonMatchers, "#match_json_schema" do
   end
 
   it "supports asserting with the match_response_schema alias" do
-    schema = create(:schema, :object)
+    schema = create(:schema, :location)
 
-    json = build(:response, :invalid_object)
+    json = build(:response, :invalid_location)
 
     expect(json).not_to match_response_schema(schema)
   end
 
   it "supports refuting with the match_response_schema alias" do
-    schema = create(:schema, :object)
+    schema = create(:schema, :location)
 
-    json = build(:response, :invalid_object)
+    json = build(:response, :invalid_location)
 
     expect(json).not_to match_response_schema(schema)
   end
 
   it "fails when the body contains a property with the wrong type" do
-    schema = create(:schema, :object)
+    schema = create(:schema, :location)
 
-    json = build(:response, :invalid_object)
+    json = build(:response, :invalid_location)
 
     expect(json).not_to match_json_schema(schema)
   end
 
   it "fails when the body is missing a required property" do
-    schema = create(:schema, :object)
+    schema = create(:schema, :location)
 
     json = build(:response, {})
 
     expect(json).not_to match_json_schema(schema)
   end
 
+  it "can reference a schema in a directory" do
+    create(:schema, :location, name: "api/v1/schema")
+
+    json = build(:response, :location)
+
+    expect(json).to match_json_schema("api/v1/schema")
+  end
+
   context "when passed a Hash" do
     it "validates that the schema matches" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :object)
+      json = build(:response, :location)
       json_as_hash = json.to_h
 
       expect(json_as_hash).to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
       json_as_hash = json.to_h
 
       expect {
@@ -75,27 +83,27 @@ describe JsonMatchers, "#match_json_schema" do
 
   context "when passed a Array" do
     it "validates a root-level Array in the JSON" do
-      schema = create(:schema, :array_of, :objects)
+      schema = create(:schema, :array_of, :locations)
 
-      json = build(:response, :object)
+      json = build(:response, :location)
       json_as_array = [json.to_h]
 
       expect(json_as_array).to match_json_schema(schema)
     end
 
     it "refutes a root-level Array in the JSON" do
-      schema = create(:schema, :array_of, :objects)
+      schema = create(:schema, :array_of, :locations)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
       json_as_array = [json.to_h]
 
       expect(json_as_array).not_to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
-      schema = create(:schema, :array_of, :object)
+      schema = create(:schema, :array_of, :location)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
       json_as_array = [json.to_h]
 
       expect {
@@ -106,18 +114,18 @@ describe JsonMatchers, "#match_json_schema" do
 
   context "when JSON is a string" do
     it "validates that the schema matches" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :object)
+      json = build(:response, :location)
       json_as_string = json.to_json
 
       expect(json_as_string).to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
       json_as_string = json.to_json
 
       expect {
@@ -127,18 +135,18 @@ describe JsonMatchers, "#match_json_schema" do
   end
 
   it "fails when the body contains a property with the wrong type" do
-    schema = create(:schema, :object)
+    schema = create(:schema, :location)
 
-    json = build(:response, :invalid_object)
+    json = build(:response, :invalid_location)
 
     expect(json).not_to match_json_schema(schema)
   end
 
   describe "the failure message" do
     it "contains the body" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
 
       expect {
         expect(json).to match_json_schema(schema)
@@ -146,9 +154,9 @@ describe JsonMatchers, "#match_json_schema" do
     end
 
     it "contains the schema" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :invalid_object)
+      json = build(:response, :invalid_location)
 
       expect {
         expect(json).to match_json_schema(schema)
@@ -156,9 +164,9 @@ describe JsonMatchers, "#match_json_schema" do
     end
 
     it "when negated, contains the body" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :object)
+      json = build(:response, :location)
 
       expect {
         expect(json).not_to match_json_schema(schema)
@@ -166,9 +174,9 @@ describe JsonMatchers, "#match_json_schema" do
     end
 
     it "when negated, contains the schema" do
-      schema = create(:schema, :object)
+      schema = create(:schema, :location)
 
-      json = build(:response, :object)
+      json = build(:response, :location)
 
       expect {
         expect(json).not_to match_json_schema(schema)
@@ -177,71 +185,39 @@ describe JsonMatchers, "#match_json_schema" do
   end
 
   it "validates against a schema that uses $ref" do
-    schema = create(:schema, :referencing_objects)
+    schema = create(:schema, :referencing_locations)
 
-    json = build(:response, :object)
+    json = build(:response, :location)
     json_as_array = [json.to_h]
 
     expect(json_as_array).to match_json_schema(schema)
   end
 
   it "fails against a schema that uses $ref" do
-    schema = create(:schema, :referencing_objects)
+    schema = create(:schema, :referencing_locations)
 
-    json = build(:response, :invalid_object)
+    json = build(:response, :invalid_location)
     json_as_array = [json.to_h]
 
     expect(json_as_array).not_to match_json_schema(schema)
   end
 
-  context "when options are passed directly to the matcher" do
-    it "forwards options to the validator" do
-      schema = create(:schema, :object)
+  it "validates against a schema referencing with 'definitions'" do
+    schema = create(:schema, :referencing_definitions)
 
-      matching_json = build(:response, :object)
-      invalid_json = build(:response, { "id": 1, "title": "bar" })
+    json = build(:response, :location)
+    json_as_hash = { "locations" => [json] }
 
-      expect(matching_json).to match_json_schema(schema, strict: true)
-      expect(invalid_json).not_to match_json_schema(schema, strict: true)
-    end
+    expect(json_as_hash).to match_json_schema(schema)
   end
 
-  context "when options are configured globally" do
-    it "forwards them to the validator" do
-      with_options(strict: true) do
-        schema = create(:schema, :object)
-
-        matching_json = build(:response, :object)
-        invalid_json = build(:response, { "id": 1, "title": "bar" })
+  it "fails against a schema referencing with 'definitions'" do
+    schema = create(:schema, :referencing_definitions)
 
-        expect(matching_json).to match_json_schema(schema)
-        expect(invalid_json).not_to match_json_schema(schema)
-      end
-    end
+    json = build(:response, :invalid_location)
+    json_as_hash = { "locations" => [json] }
 
-    context "when configured to record errors" do
-      it "includes the reasons for failure in the exception's message" do
-        with_options(record_errors: true) do
-          schema = create(:schema, {
-            "type": "object",
-            "properties": {
-              "username": {
-                "allOf": [
-                  { "type": "string" },
-                  { "minLength": 5 },
-                ],
-              },
-            },
-          })
-
-          invalid_json = build(:response, { "username": "foo" })
-
-          expect {
-            expect(invalid_json).to match_json_schema(schema)
-          }.to raise_error(/minimum/)
-        end
-      end
-    end
+    expect(json_as_hash).not_to match_json_schema(schema)
   end
 
   def raise_error_containing(schema_or_body)