json_matchers 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5922bc3d062651cf85a9aa16420365e544abe115adb3e79683360abf06a806e2
-  data.tar.gz: 8413dc48cb9588a41149ebb7a710ab358138578f72f22b212a61f809bd784596
+  metadata.gz: 03b79f9a5c8394f6e8ccbd26d6c066519e5d2a25ad6b623765a48f524ba38bf0
+  data.tar.gz: 00421a6718fff3b21d1c50382ea5b9d5f855dbfe4d2522dbf50db217f2993b8f
 SHA512:
-  metadata.gz: 88663040a28f53d62815fb2544a1c3fe7760bd294d99f373f879e7b106d269e5961da3a7a29252888d3be55da242a530cb8d2d5c533b983e4b35bf8db6a46190
-  data.tar.gz: 1ec7eba89fcad7f02e0782032c8cdb7938d4ad1d4c575022f183881e8e75d08b8b2c76c16cd46d8eb6fda3fff481abe1cfce287802f71bbf264a1330ad8d2f45
+  metadata.gz: 9b4cc33ad05676e0ac2133c79d627ece2994d0a21878ad6269c3145081d3cf1fe0e193928e1ca312660baa418b69f5cd33661aa0f070301d50f51436b72d3c0a
+  data.tar.gz: 830aa3570c9ae06fcd3986323d2dd0a3763c7fd91c62e09cf7029e184612ec15c5227fa706afbfe3cb8471c61c4f8dd85fa2cea68f9fd5edb704f7c7bfdbfffc

data/.travis.yml

@@ -4,4 +4,6 @@ language: ruby
 notifications:
   email: false
 rvm:
-- 2.5.0
+  - 2.5.0
+before_install:
+  - gem update --system

data/NEWS.md

@@ -1,6 +1,15 @@
 master
 ======
 
+0.10.0
+======
+
+* *BREAKING CHANGE* Implement the validation with the `json_schema` gem instead
+  of `json-schema`. [#31]
+* *BREAKING CHANGE* - remove support for configuring validation options.
+
+[#31]: https://github.com/thoughtbot/json_matchers/pull/31
+
 0.9.0
 =====
 

data/README.md

@@ -24,7 +24,7 @@ Or install it yourself as:
 
 Inspired by [Validating JSON Schemas with an RSpec Matcher][original-blog-post].
 
-[original-blog-post]: (http://robots.thoughtbot.com/validating-json-schemas-with-an-rspec-matcher)
+[original-blog-post]: (https://robots.thoughtbot.com/validating-json-schemas-with-an-rspec-matcher)
 
 First, configure it in your test suite's helper file:
 
@@ -37,7 +37,7 @@ First, configure it in your test suite's helper file:
 ```ruby
 require "json_matchers/rspec"
 
-JsonMatchers.schema_root = "/spec/support/api/schemas"
+JsonMatchers.schema_root = "spec/support/api/schemas"
 ```
 
 #### Minitest
@@ -48,33 +48,34 @@ JsonMatchers.schema_root = "/spec/support/api/schemas"
 require "minitest/autorun"
 require "json_matchers/minitest/assertions"
 
-JsonMatchers.schema_root = "/test/support/api/schemas"
+JsonMatchers.schema_root = "test/support/api/schemas"
 
 Minitest::Test.send(:include, JsonMatchers::Minitest::Assertions)
 ```
 
 ### Declare
 
-Declare your [JSON Schema](http://json-schema.org/example1.html) in the schema
+Declare your [JSON Schema](https://json-schema.org/example1.html) in the schema
 directory.
 
-`spec/support/api/schemas/posts.json` or `test/support/api/schemas/posts.json`:
+`spec/support/api/schemas/location.json` or
+`test/support/api/schemas/location.json`:
+
+Define your [JSON Schema](https://json-schema.org/example1.html) in the schema
+directory.
 
 ```json
 {
+  "id": "https://json-schema.org/geo",
+  "$schema": "https://json-schema.org/draft-06/schema#",
+  "description": "A geographical coordinate",
   "type": "object",
-  "required": ["posts"],
   "properties": {
-    "posts": {
-      "type": "array",
-      "items":{
-        "required": ["id", "title", "body"],
-        "properties": {
-          "id": { "type": "integer" },
-          "title": { "type": "string" },
-          "body": { "type": "string" }
-        }
-      }
+    "latitude": {
+      "type": "number"
+    },
+    "longitude": {
+      "type": "number"
     }
   }
 }
@@ -87,15 +88,15 @@ directory.
 Validate a JSON response, a Hash, or a String against a JSON Schema with
 `match_json_schema`:
 
-`spec/requests/posts_spec.rb`
+`spec/requests/locations_spec.rb`
 
 ```ruby
-describe "GET /posts" do
-  it "returns Posts" do
-    get posts_path, format: :json
+describe "GET /locations" do
+  it "returns Locations" do
+    get locations_path, format: :json
 
     expect(response.status).to eq 200
-    expect(response).to match_json_schema("posts")
+    expect(response).to match_json_schema("locations")
   end
 end
 ```
@@ -105,107 +106,129 @@ end
 Validate a JSON response, a Hash, or a String against a JSON Schema with
 `assert_matches_json_schema`:
 
-`test/integration/posts_test.rb`
+`test/integration/locations_test.rb`
 
 ```ruby
-def test_GET_posts_returns_Posts
-  get posts_path, format: :json
+def test_GET_posts_returns_Locations
+  get locations_path, format: :json
 
   assert_equal response.status, 200
-  assert_matches_json_schema response, "posts"
+  assert_matches_json_schema response, "locations"
 end
 ```
 
-### DEPRECATED: Passing options to the validator
+### Embedding other Schemas
 
-The matcher accepts options, which it passes to the validator:
+To re-use other schema definitions, include `$ref` keys that refer to their
+definitions.
 
-`spec/requests/posts_spec.rb`
+First, declare the singular version of your schema.
 
-```ruby
-describe "GET /posts" do
-  it "returns Posts" do
-    get posts_path, format: :json
+`spec/support/api/schemas/user.json`:
 
-    expect(response.status).to eq 200
-    expect(response).to match_json_schema("posts", strict: true)
-  end
-end
+```json
+{
+  "id": "file:/user.json#",
+  "type": "object",
+  "required": ["id"],
+  "properties": {
+    "id": { "type": "integer" },
+    "name": { "type": "string" },
+    "address": { "type": "string" },
+  },
+}
 ```
 
-A list of available options can be found [here][options].
-
-[options]: https://github.com/ruby-json-schema/json-schema/blob/2.2.4/lib/json-schema/validator.rb#L160-L162
-
-### DEPRECATED: Global matcher options
-
-To configure the default options passed to *all* matchers, call
-`JsonMatchers.configure`.
+Then, when you declare your collection schema, reference your singular schemas.
 
-`spec/support/json_matchers.rb`:
+`spec/support/api/schemas/users/index.json`:
 
-```rb
-JsonMatchers.configure do |config|
-  config.options[:strict] = true
-end
+```json
+{
+  "id": "file:/users/index.json#",
+  "type": "object",
+  "definitions": {
+    "users": {
+      "description": "A collection of users",
+      "example": [{ "id": "1" }],
+      "type": "array",
+      "items": {
+        "$ref": "file:/user.json#"
+      },
+    },
+  },
+  "required": ["users"],
+  "properties": {
+    "users": {
+      "$ref": "#/definitions/users"
+    }
+  },
+}
 ```
 
-A list of available options can be found [here][options].
+NOTE: `$ref` resolves paths relative to the schema in question.
 
-### DEPRECATED: Default matcher options
+In this case `"user.json"` and `"users/index.json"` are resolved relative to
+`"spec/support/api/schemas"` or `"test/support/api/schemas"`.
 
-* `record_errors: true` - *NOTE* `json_matchers` will always set
-  `record_errors: true`. This cannot be overridden.
+To learn more about `$ref`, check out
+[Understanding JSON Schema Structuring][$ref].
 
-### Embedding other Schemas
+[$ref]: https://spacetelescope.github.io/understanding-json-schema/structuring.html
 
-To DRY up your schema definitions, use JSON schema's `$ref`.
+### Declaring a schema in a Subdirectory
 
-First, declare the singular version of your schema.
+Nesting a schema within a subdirectory is also supported:
+
+`spec/support/api/schemas/api/v1/location.json`:
 
-`spec/support/api/schemas/post.json`:
 
 ```json
 {
+  "id": "https://json-schema.org/geo",
+  "$schema": "https://json-schema.org/draft-06/schema#",
+  "description": "A geographical coordinate",
   "type": "object",
-  "required": ["id", "title", "body"],
   "properties": {
-    "id": { "type": "integer" },
-    "title": { "type": "string" },
-    "body": { "type": "string" }
+    "latitude": {
+      "type": "number"
+    },
+    "longitude": {
+      "type": "number"
+    }
   }
 }
 ```
 
-Then, when you declare your collection schema, reference your singular schemas.
+`spec/requests/api/v1/locations_spec.rb`:
 
-`spec/support/api/schemas/posts.json`:
+```ruby
+describe "GET api/v1/locations" do
+  it "returns Locations" do
+    get locations_path, format: :json
 
-```json
-{
-  "type": "object",
-  "required": ["posts"],
-  "properties": {
-    "posts": {
-      "type": "array",
-      "items": { "$ref": "post.json" }
-    }
-  }
-}
+    expect(response.status).to eq 200
+    expect(response).to match_json_schema("api/v1/location")
+  end
+end
 ```
 
-NOTE: `$ref` resolves paths relative to the schema in question.
+## Configuration
+
+By default, the schema directory is `spec/support/api/schemas`.
 
-In this case `"post.json"` will be resolved relative to
-`"spec/support/api/schemas"`.
+This can be configured via `JsonMatchers.schema_root`.
 
-To learn more about `$ref`, check out [Understanding JSON Schema Structuring](http://spacetelescope.github.io/understanding-json-schema/structuring.html)
+```ruby
+# spec/support/json_matchers.rb
+
+JsonMatchers.schema_root = "docs/api/schemas"
+```
 
 ## Upgrading from `0.9.x`
 
-After `json_matchers@0.9.x`, calls to `match_json_schema` and
-`match_response_schema` no longer accept options, and `JsonMatchers.configure`
-will been removed.
+Calls to `match_json_schema` and `match_response_schema` no longer accept
+options, and `JsonMatchers.configure` has been removed.
 
 ## Contributing
 

data/json_matchers.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency("json-schema", "~> 2.7")
+  spec.add_dependency("json_schema")
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "pry"

data/lib/json_matchers.rb

@@ -1,5 +1,5 @@
+require "pathname"
 require "json_matchers/version"
-require "json_matchers/configuration"
 require "json_matchers/matcher"
 require "json_matchers/errors"
 
@@ -9,6 +9,6 @@ module JsonMatchers
   end
 
   def self.path_to_schema(schema_name)
-    Pathname(schema_root).join("#{schema_name}.json")
+    Pathname.new(schema_root).join("#{schema_name}.json")
   end
 end

data/lib/json_matchers/assertion.rb

@@ -5,16 +5,16 @@ require "json_matchers/matcher"
 
 module JsonMatchers
   class Assertion
-    def initialize(schema_name, **options)
-      @schema_name = schema_name
+    def initialize(schema_name)
+      @schema_name = schema_name.to_s
       @schema_path = JsonMatchers.path_to_schema(schema_name)
-      @matcher = Matcher.new(schema_path, options)
+      @matcher = Matcher.new(schema_path)
     end
 
     def valid?(json)
       @payload = Payload.new(json)
 
-      matcher.matches?(payload.to_s)
+      matcher.matches?(payload)
     end
 
     def valid_failure_message
@@ -58,7 +58,7 @@ not to match schema "#{schema_name}":
     end
 
     def schema_body
-      File.read(schema_path)
+      schema_path.read
     end
 
     def format_json(json)

data/lib/json_matchers/matcher.rb

@@ -1,24 +1,18 @@
-require "json-schema"
+require "json_schema"
+require "json_matchers/parser"
 require "json_matchers/validator"
 
 module JsonMatchers
   class Matcher
-    def initialize(schema_path, options = {})
+    def initialize(schema_path)
       @schema_path = schema_path
-      @options = default_options.merge(options)
+      @document_store = build_and_populate_document_store
     end
 
     def matches?(payload)
-      validator = build_validator(payload)
-
-      self.errors = validator.validate!
+      self.errors = validator.validate(payload)
 
       errors.empty?
-    rescue JSON::Schema::ValidationError => error
-      self.errors = [error.message]
-      false
-    rescue JSON::Schema::JsonParseError
-      raise InvalidSchemaError
     end
 
     def validation_failure_message
@@ -27,19 +21,22 @@ module JsonMatchers
 
     private
 
-    attr_reader :schema_path, :options
     attr_accessor :errors
+    attr_reader :document_store, :schema_path
 
-    def default_options
-      JsonMatchers.configuration.options || {}
+    def validator
+      Validator.new(schema_path: schema_path, document_store: document_store)
     end
 
-    def build_validator(payload)
-      Validator.new(
-        options: options,
-        payload: payload,
-        schema_path: schema_path,
-      )
+    def build_and_populate_document_store
+      document_store = JsonSchema::DocumentStore.new
+
+      Dir.glob("#{JsonMatchers.schema_root}/**/*.json").
+        map { |path| Pathname.new(path) }.
+        map { |schema_path| Parser.new(schema_path).parse }.
+        each { |schema| document_store.add_schema(schema) }
+
+      document_store
     end
   end
 end

data/lib/json_matchers/parser.rb

@@ -0,0 +1,21 @@
+module JsonMatchers
+  class Parser
+    def initialize(schema_path)
+      @schema_path = schema_path
+    end
+
+    def parse
+      JsonSchema.parse!(schema_data)
+    rescue JSON::ParserError, JsonSchema::SchemaError => error
+      raise InvalidSchemaError.new(error)
+    end
+
+    private
+
+    attr_reader :schema_path
+
+    def schema_data
+      JSON.parse(schema_path.read)
+    end
+  end
+end