json_matchers 0.7.3 → 0.8.0

data/lib/json_matchers/payload.rb

@@ -18,7 +18,7 @@ module JsonMatchers
       elsif payload.is_a?(Array) || payload.is_a?(Hash)
         payload.to_json
       else
-        payload
+        payload.to_s
       end
     end
   end

data/lib/json_matchers/rspec.rb

@@ -1,94 +1,34 @@
-require "delegate"
 require "json_matchers"
-require "json_matchers/payload"
+require "json_matchers/assertion"
 
 module JsonMatchers
-  class RSpec < SimpleDelegator
-    attr_reader :schema_name
-
-    def initialize(schema_name, **options)
-      @schema_name = schema_name
-
-      super(JsonMatchers::Matcher.new(schema_path, options))
-    end
-
-    def failure_message(json)
-      <<-FAIL
-#{validation_failure_message}
-
----
-
-expected
-
-#{pretty_json(json)}
-
-to match schema "#{schema_name}":
-
-#{pretty_json(schema_body)}
-
-      FAIL
-    end
-
-    def failure_message_when_negated(json)
-      <<-FAIL
-#{validation_failure_message}
-
----
-
-expected
-
-#{pretty_json(json)}
+  self.schema_root = File.join("spec", "support", "api", "schemas")
+end
 
-not to match schema "#{schema_name}":
+RSpec::Matchers.define :match_json_schema do |schema_name, **options|
+  assertion = JsonMatchers::Assertion.new(schema_name.to_s, options)
 
-#{pretty_json(schema_body)}
+  match do |json|
+    assertion.valid?(json)
+  end
 
-      FAIL
+  if respond_to?(:failure_message)
+    failure_message do
+      assertion.valid_failure_message
     end
 
-    private
-
-    def pretty_json(json)
-      payload = Payload.new(json).to_s
-
-      JSON.pretty_generate(JSON.parse(payload))
+    failure_message_when_negated do
+      assertion.invalid_failure_message
     end
-
-    def schema_path
-      JsonMatchers.path_to_schema(schema_name)
+  else
+    failure_message_for_should do
+      assertion.valid_failure_message
     end
 
-    def schema_body
-      File.read(schema_path)
+    failure_message_for_should_not do
+      assertion.invalid_failure_message
     end
   end
 end
 
-if RSpec.respond_to?(:configure)
-  RSpec::Matchers.define :match_json_schema do |schema_name, **options|
-    matcher = JsonMatchers::RSpec.new(schema_name, options)
-
-    match do |json|
-      matcher.matches?(json)
-    end
-
-    if respond_to?(:failure_message)
-      failure_message do |json|
-        matcher.failure_message(json)
-      end
-
-      failure_message_when_negated do |json|
-        matcher.failure_message_when_negated(json)
-      end
-    else
-      failure_message_for_should do |json|
-        matcher.failure_message(json)
-      end
-
-      failure_message_for_should_not do |json|
-        matcher.failure_message_when_negated(json)
-      end
-    end
-  end
-  RSpec::Matchers.alias_matcher :match_response_schema, :match_json_schema
-end
+RSpec::Matchers.alias_matcher :match_response_schema, :match_json_schema

data/lib/json_matchers/validator.rb

@@ -1,11 +1,10 @@
 require "json-schema"
-require "json_matchers/payload"
 
 module JsonMatchers
   class Validator
-    def initialize(options:, response:, schema_path:)
+    def initialize(options:, payload:, schema_path:)
       @options = options.dup
-      @payload = Payload.new(response).to_s
+      @payload = payload
       @schema_path = schema_path.to_s
     end
 

data/lib/json_matchers/version.rb

@@ -1,3 +1,3 @@
 module JsonMatchers
-  VERSION = "0.7.3"
+  VERSION = "0.8.0"
 end

data/spec/factories.rb

@@ -0,0 +1,88 @@
+require "json_matchers/payload"
+require_relative "./support/fake_response"
+require_relative "./support/fake_schema"
+
+FactoryBot.define do
+  factory :response, class: FakeResponse do
+    skip_create
+
+    trait :object do
+      body { { "id": 1 } }
+    end
+
+    trait :invalid_object do
+      body { { "id": "1" } }
+    end
+
+    initialize_with do
+      body = attributes.fetch(:body, nil)
+      json = attributes.except(:body)
+      payload = JsonMatchers::Payload.new(body || json)
+
+      FakeResponse.new(payload.to_s)
+    end
+  end
+
+  factory :schema, class: FakeSchema do
+    skip_create
+
+    sequence(:name) { |n| "json_schema-#{n}" }
+
+    trait :invalid do
+      json { "" }
+    end
+
+    trait :object do
+      json do
+        {
+          "type": "object",
+          "required": [
+            "id",
+          ],
+          "properties": {
+            "id": { "type": "number" },
+          },
+          "additionalProperties": false,
+        }
+      end
+    end
+    trait(:objects) { object }
+
+    trait :array_of do
+      initialize_with do
+        schema_body_as_json = attributes.fetch(:json, nil)
+        schema_body = attributes.except(:json, :name)
+
+        FakeSchema.new(name, {
+          "type": "array",
+          "items": schema_body_as_json || schema_body,
+        })
+      end
+    end
+
+    trait :referencing_objects do
+      association :items, factory: [:schema, :object]
+
+      initialize_with do
+        FakeSchema.new(name, {
+          "type": "array",
+          "items": { "$ref": "#{items.name}.json" },
+        })
+      end
+    end
+
+    initialize_with do
+      schema_body_as_json = attributes.fetch(:json, nil)
+      schema_body = attributes.except(:json, :name)
+
+      FakeSchema.new(name, schema_body_as_json || schema_body)
+    end
+
+    after :create do |schema|
+      path = File.join(JsonMatchers.schema_root, "#{schema.name}.json")
+      payload = JsonMatchers::Payload.new(schema.json)
+
+      IO.write(path, payload)
+    end
+  end
+end

data/spec/json_matchers/match_json_schema_spec.rb

@@ -1,242 +1,228 @@
+require "active_support/core_ext/string"
+
 describe JsonMatchers, "#match_json_schema" do
-  it "fails with an invalid JSON body" do
-    create_schema("foo", "")
+  it "fails with an invalid JSON schema" do
+    schema = create(:schema, :invalid)
+
+    json = build(:response)
 
     expect {
-      expect(response_for("")).to match_json_schema("foo")
+      expect(json).to match_json_schema(schema)
     }.to raise_error(JsonMatchers::InvalidSchemaError)
   end
 
   it "does not fail with an empty JSON body" do
-    create_schema("foo", {})
+    schema = create(:schema, {})
+
+    json = build(:response, {})
+
+    expect(json).to match_json_schema(schema)
+  end
+
+  it "supports asserting with the match_response_schema alias" do
+    schema = create(:schema, :object)
+
+    json = build(:response, :invalid_object)
+
+    expect(json).not_to match_response_schema(schema)
+  end
+
+  it "supports refuting with the match_response_schema alias" do
+    schema = create(:schema, :object)
+
+    json = build(:response, :invalid_object)
+
+    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)
 
-    expect(response_for({})).to match_json_schema("foo")
+    json = build(:response, :invalid_object)
+
+    expect(json).not_to match_json_schema(schema)
   end
 
   it "fails when the body is missing a required property" do
-    create_schema("foo_schema", {
-      "type": "object",
-      "required": ["foo"],
-    })
+    schema = create(:schema, :object)
+
+    json = build(:response, {})
 
-    expect(response_for({})).not_to match_json_schema("foo_schema")
+    expect(json).not_to match_json_schema(schema)
   end
 
   context "when passed a Hash" do
-    it "validates when the schema matches" do
-      create_schema("foo_schema", {
-        "type": "object",
-        "required": [
-          "id",
-        ],
-        "properties": {
-          "id": { "type": "number" },
-        },
-        "additionalProperties": false,
-      })
-
-      expect({ "id": 1 }).to match_json_schema("foo_schema")
+    it "validates that the schema matches" do
+      schema = create(:schema, :object)
+
+      json = build(:response, :object)
+      json_as_hash = json.to_h
+
+      expect(json_as_hash).to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
-      create_schema("foo_schema", {
-        "type": "object",
-        "required": [
-          "id",
-        ],
-        "properties": {
-          "id": { "type": "number" },
-        },
-        "additionalProperties": false,
-      })
+      schema = create(:schema, :object)
+
+      json = build(:response, :invalid_object)
+      json_as_hash = json.to_h
 
       expect {
-        expect({ "id": "1" }).to match_json_schema("foo_schema")
-      }.to raise_formatted_error(%{{ "type": "number" }})
+        expect(json_as_hash).to match_json_schema(schema)
+      }.to raise_error_containing(schema)
     end
   end
 
   context "when passed a Array" do
-    it "validates when the schema matches" do
-      create_schema("foo_schema", {
-        "type": "array",
-        "items": {
-          "required": [
-            "id",
-          ],
-          "properties": {
-            "id": { "type": "number" },
-          },
-          "additionalProperties": false,
-        },
-      })
-
-      expect([{ "id": 1 }]).to match_json_schema("foo_schema")
+    it "validates a root-level Array in the JSON" do
+      schema = create(:schema, :array_of, :objects)
+
+      json = build(:response, :object)
+      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)
+
+      json = build(:response, :invalid_object)
+      json_as_array = [json.to_h]
+
+      expect(json_as_array).not_to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
-      create_schema("foo_schema", {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "required": [
-            "id",
-          ],
-          "properties": {
-            "id": { "type": "number" },
-          },
-          "additionalProperties": false,
-        },
-      })
+      schema = create(:schema, :array_of, :object)
+
+      json = build(:response, :invalid_object)
+      json_as_array = [json.to_h]
 
       expect {
-        expect([{ "id": "1" }]).to match_json_schema("foo_schema")
-      }.to raise_formatted_error(%{{ "type": "number" }})
+        expect(json_as_array).to match_json_schema(schema)
+      }.to raise_error_containing(schema)
     end
   end
 
   context "when JSON is a string" do
-    before(:each) do
-      create_schema("foo_schema", {
-        "type": "object",
-        "required": [
-          "id",
-        ],
-        "properties": {
-          "id": { "type": "number" },
-        },
-        "additionalProperties": false,
-      })
-    end
+    it "validates that the schema matches" do
+      schema = create(:schema, :object)
+
+      json = build(:response, :object)
+      json_as_string = json.to_json
 
-    it "validates when the schema matches" do
-      expect({ "id": 1 }.to_json).
-        to match_json_schema("foo_schema")
+      expect(json_as_string).to match_json_schema(schema)
     end
 
     it "fails with message when negated" do
+      schema = create(:schema, :object)
+
+      json = build(:response, :invalid_object)
+      json_as_string = json.to_json
+
       expect {
-        expect({ "id": "1" }.to_json).to match_json_schema("foo_schema")
-      }.to raise_formatted_error(%{{ "type": "number" }})
+        expect(json_as_string).to match_json_schema(schema)
+      }.to raise_error_containing(schema)
     end
   end
 
   it "fails when the body contains a property with the wrong type" do
-    create_schema("foo_schema", {
-      "type": "object",
-      "properties": {
-        "foo": { "type": "string" },
-      },
-    })
-
-    expect(response_for("foo": 1)).
-      not_to match_json_schema("foo_schema")
-  end
+    schema = create(:schema, :object)
 
-  it "contains the body in the failure message" do
-    create_schema("foo", { "type": "array" })
+    json = build(:response, :invalid_object)
 
-    expect {
-      expect(response_for("bar": 5)).to match_json_schema("foo")
-    }.to raise_formatted_error(%{{ "bar": 5 }})
+    expect(json).not_to match_json_schema(schema)
   end
 
-  it "contains the body in the failure message when negated" do
-    create_schema("foo", { "type": "array" })
+  describe "the failure message" do
+    it "contains the body" do
+      schema = create(:schema, :object)
 
-    expect {
-      expect(response_for([])).not_to match_json_schema("foo")
-    }.to raise_formatted_error("[ ]")
-  end
+      json = build(:response, :invalid_object)
 
-  it "contains the schema in the failure message" do
-    schema = { "type": "array" }
-    create_schema("foo", schema)
+      expect {
+        expect(json).to match_json_schema(schema)
+      }.to raise_error_containing(json)
+    end
 
-    expect {
-      expect(response_for("bar": 5)).to match_json_schema("foo")
-    }.to raise_formatted_error(%{{ "type": "array" }})
-  end
+    it "contains the schema" do
+      schema = create(:schema, :object)
 
-  it "contains the schema in the failure message when negated" do
-    schema = { "type": "array" }
-    create_schema("foo", schema)
+      json = build(:response, :invalid_object)
 
-    expect {
-      expect(response_for([])).not_to match_json_schema("foo")
-    }.to raise_formatted_error(%{{ "type": "array" }})
+      expect {
+        expect(json).to match_json_schema(schema)
+      }.to raise_error_containing(schema)
+    end
+
+    it "when negated, contains the body" do
+      schema = create(:schema, :object)
+
+      json = build(:response, :object)
+
+      expect {
+        expect(json).not_to match_json_schema(schema)
+      }.to raise_error_containing(json)
+    end
+
+    it "when negated, contains the schema" do
+      schema = create(:schema, :object)
+
+      json = build(:response, :object)
+
+      expect {
+        expect(json).not_to match_json_schema(schema)
+      }.to raise_error_containing(schema)
+    end
   end
 
-  it "does not fail when the schema matches" do
-    create_schema("array_schema", {
-      "type": "array",
-      "items": { "type": "string" },
-    })
+  it "validates against a schema that uses $ref" do
+    schema = create(:schema, :referencing_objects)
+
+    json = build(:response, :object)
+    json_as_array = [json.to_h]
 
-    expect(response_for(["valid"])).to match_json_schema("array_schema")
+    expect(json_as_array).to match_json_schema(schema)
   end
 
-  it "supports $ref" do
-    create_schema("single", {
-      "type": "object",
-      "required": ["foo"],
-      "properties": {
-        "foo": { "type": "string" },
-      },
-    })
-    create_schema("collection", {
-      "type": "array",
-      "items": { "$ref": "single.json" },
-    })
-
-    valid_response = response_for([{ "foo": "is a string" }])
-    invalid_response = response_for([{ "foo": 0 }])
-
-    expect(valid_response).to match_json_schema("collection")
-    expect(valid_response).to match_response_schema("collection")
-    expect(invalid_response).not_to match_json_schema("collection")
-    expect(invalid_response).not_to match_response_schema("collection")
+  it "fails against a schema that uses $ref" do
+    schema = create(:schema, :referencing_objects)
+
+    json = build(:response, :invalid_object)
+    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
-      create_schema("foo_schema", {
-        "type": "object",
-        "properties": {
-          "id": { "type": "number" },
-          "title": { "type": "string" },
-        },
-      })
-
-      expect(response_for({ "id": 1, "title": "bar" })).
-        to match_json_schema("foo_schema", strict: true)
-      expect(response_for({ "id": 1 })).
-        not_to match_json_schema("foo_schema", strict: true)
+      schema = create(:schema, :object)
+
+      matching_json = build(:response, :object)
+      invalid_json = build(:response, { "id": 1, "title": "bar" })
+
+      expect(matching_json).to match_json_schema(schema, strict: true)
+      expect(invalid_json).not_to match_json_schema(schema, strict: true)
     end
   end
 
   context "when options are configured globally" do
     it "forwards them to the validator" do
       with_options(strict: true) do
-        create_schema("foo_schema", {
-          "type": "object",
-          "properties": {
-            "id": { "type": "number" },
-            "title": { "type": "string" },
-          },
-        })
-
-        expect(response_for({ "id": 1, "title": "bar" })).
-          to match_json_schema("foo_schema")
-        expect(response_for({ "id": 1 })).
-          not_to match_json_schema("foo_schema")
+        schema = create(:schema, :object)
+
+        matching_json = build(:response, :object)
+        invalid_json = build(:response, { "id": 1, "title": "bar" })
+
+        expect(matching_json).to match_json_schema(schema)
+        expect(invalid_json).not_to match_json_schema(schema)
       end
     end
 
     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
-          create_schema("foo_schema", {
+          schema = create(:schema, {
             "type": "object",
             "properties": {
               "username": {
@@ -247,22 +233,22 @@ describe JsonMatchers, "#match_json_schema" do
               },
             },
           })
-          invalid_payload = response_for({ "username": "foo" })
+
+          invalid_json = build(:response, { "username": "foo" })
 
           expect {
-            expect(invalid_payload).to match_json_schema("foo_schema")
+            expect(invalid_json).to match_json_schema(schema)
           }.to raise_error(/minimum/)
         end
       end
     end
   end
 
-  def raise_formatted_error(error_message)
+  def raise_error_containing(schema_or_body)
     raise_error do |error|
-      sanitized_message = error.message.
-        gsub(/\A[[:space:]]+/, "").
-        gsub(/[[:space:]]+\z/, "").
-        gsub(/[[:space:]]+/, " ")
+      sanitized_message = error.message.squish
+      json = JSON.pretty_generate(schema_or_body.to_h)
+      error_message = json.squish
 
       expect(sanitized_message).to include(error_message)
     end