json-matchers 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be6efc3180dbb7fd3f49c438edb2c1d5c096342d
-  data.tar.gz: 1808696767e661d8393224272dd30a7cc5dd9a23
+  metadata.gz: bb439f8416d8a3a906aa121c633bc82bd63a57c8
+  data.tar.gz: 8269af55c9374e98ea6329aaab7a7f46c8f028ef
 SHA512:
-  metadata.gz: ed7c67b4b54f84cf64cabe106c54aac6da88fda5432e948e7bf993a8e5caef1aa20fa3a8a151eedc0efff256d6646cb12c4980df3161d1d91b44fe60e40b4c29
-  data.tar.gz: 6575e174274e7be924af6dce791b590d10d6f4fb16d392c24e497afe8c171c7a892f0238cc37f3f1d3261c98ad99d66ebf691221f0312c3132a0e80f23647d33
+  metadata.gz: 4b14aa4ae10098b51424ecd895385c49c5227704ac18bdd452acb18ab81a1ed4c8142e79374eda069991fe283532d35c4d72c6006626697321199088b64710be
+  data.tar.gz: 00a674630bea1085faaceefddb183b13ea7ee039125b6ec1b0c930d3bf8116d80c0ae44da84b7103a2f414f62f89bb7975e678e74defac3320d86730615b0460

data/NEWS.md

@@ -1,3 +1,10 @@
+# 0.1.0
+
+## Breaking Changes
+
+* Remove `schema_for` in favor of using `$ref`. To learn more about `$ref`,
+  check out [Understanding JSON Schema Structuring](http://spacetelescope.github.io/understanding-json-schema/structuring.html)
+
 # 0.0.1
 
 ## Features

data/README.md

@@ -65,7 +65,9 @@ describe "GET /posts" do
 end
 ```
 
-You can even embed schemas inside other schemas!
+### Embedding other Schemas
+
+To DRY up your schema definitions, use JSON schema's `$ref`.
 
 First, declare the singular version of your schema.
 
@@ -83,8 +85,7 @@ First, declare the singular version of your schema.
 }
 ```
 
-Then, when you declare your collection schema, embed the singular schema with
-`ERB` and `schema_for`!
+Then, when you declare your collection schema, reference your singular schemas.
 
 ```json
 # spec/support/api/schemas/posts.json
@@ -95,12 +96,19 @@ Then, when you declare your collection schema, embed the singular schema with
   "properties": {
     "posts": {
       "type": "array",
-      "items": <%= schema_for("post") %>
+      "items": { "$ref": "post.json" }
     }
   }
 }
 ```
 
+NOTE: `$ref` resolves paths relative to the schema in question.
+
+In this case `"post.json"` will be resolved relative to
+`"spec/support/api/schemas"`.
+
+To learn more about `$ref`, check out [Understanding JSON Schema Structuring](http://spacetelescope.github.io/understanding-json-schema/structuring.html)
+
 ## Configuration
 
 By default, the schema directory is `spec/support/api/schemas`.
@@ -109,14 +117,14 @@ This can be configured via `JSON::Matchers.schema_root`.
 
 
 ```ruby
-# spec/support/shoulda-matchers-json.rb
+# spec/support/json-matchers.rb
 
 JSON::Matchers.schema_root = "docs/api/schemas"
 ```
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/shoulda-matchers-json/fork )
+1. Fork it ( https://github.com/[my-github-username]/json-matchers/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/json/matchers.rb

@@ -1,6 +1,5 @@
 require "json/matchers/version"
 require "json/matchers/matcher"
-require "json/matchers/schema_parser"
 require "json/matchers/errors"
 require "active_support/all"
 
@@ -10,12 +9,9 @@ module JSON
 
     self.schema_root = "#{Dir.pwd}/spec/support/api/schemas"
 
-    def match_response_schema(schema_name)
-      schema_parser = SchemaParser.new(schema_root)
-
-      Matcher.new(schema_parser.schema_for(schema_name))
+    def self.path_to_schema(schema_name)
+      Pathname(schema_root).join("#{schema_name}.json")
     end
-    alias match_json_schema match_response_schema
   end
 end
 

data/lib/json/matchers/errors.rb

@@ -1,7 +1,6 @@
 module JSON
   module Matchers
-    InvalidError = Class.new(StandardError)
-    DoesNotMatch = Class.new(InvalidError)
+    InvalidSchemaError = Class.new(StandardError)
     MissingSchema = Class.new(Errno::ENOENT)
   end
 end

data/lib/json/matchers/matcher.rb

@@ -2,19 +2,15 @@ require "json-schema"
 
 module JSON
   module Matchers
-    Matcher = Struct.new(:schema) do
+    Matcher = Struct.new(:schema_path) do
       def matches?(response)
-        JSON::Validator.validate!(json_schema, response.body, strict: true)
+        @response = response
+
+        JSON::Validator.validate!(schema_path.to_s, response.body, strict: true)
       rescue JSON::Schema::ValidationError
-        raise DoesNotMatch, response.body
+        false
       rescue JSON::ParserError
-        raise InvalidError
-      end
-
-      private
-
-      def json_schema
-        JSON.parse(schema)
+        raise InvalidSchemaError
       end
     end
   end

data/lib/json/matchers/rspec.rb

@@ -1,5 +1,10 @@
 if RSpec.respond_to?(:configure)
-  RSpec.configure do |config|
-    config.include JSON::Matchers
+  RSpec::Matchers.define :match_response_schema do |schema_name|
+    match do |response|
+      schema_path = JSON::Matchers.path_to_schema(schema_name)
+      matcher = JSON::Matchers::Matcher.new(schema_path)
+
+      matcher.matches?(response)
+    end
   end
 end

data/lib/json/matchers/version.rb

@@ -1,5 +1,5 @@
 module JSON
   module Matchers
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/spec/json/matchers/match_response_schema_spec.rb

@@ -4,7 +4,7 @@ describe JSON::Matchers, "#match_response_schema" do
 
     expect {
       expect(response_for("")).to match_response_schema("foo")
-    }.to raise_error(JSON::Matchers::InvalidError)
+    }.to raise_error(JSON::Matchers::InvalidSchemaError)
   end
 
   it "does not fail with an empty JSON body" do
@@ -19,9 +19,7 @@ describe JSON::Matchers, "#match_response_schema" do
       required: ["foo"],
     })
 
-    expect {
-      expect(response_for({})).to match_response_schema("array_schema")
-    }.to raise_error(JSON::Matchers::DoesNotMatch, /{}/)
+    expect(response_for({})).not_to match_response_schema("array_schema")
   end
 
   it "fails when the body contains a property with the wrong type" do
@@ -32,9 +30,7 @@ describe JSON::Matchers, "#match_response_schema" do
       }
     })
 
-    expect {
-      expect(response_for({foo: 1})).to match_response_schema("array_schema")
-    }.to raise_error(JSON::Matchers::DoesNotMatch, /{"foo":1}/)
+    expect(response_for({foo: 1})).not_to match_response_schema("array_schema")
   end
 
   it "does not fail when the schema matches" do
@@ -46,14 +42,23 @@ describe JSON::Matchers, "#match_response_schema" do
     expect(response_for(["valid"])).to match_response_schema("array_schema")
   end
 
-  it "supports ERB" do
-    create_schema "array_schema", <<-JSON.strip_heredoc
-    {
-      "type": "array",
-      "items": <%= { type: "string" }.to_json %>
-    }
-    JSON
+  it "supports $ref" do
+    create_schema("single", {
+      "type" => "object",
+      "required" => ["foo"],
+      "properties" => {
+        "foo" => { "type" => "string" }
+      }
+    })
+    create_schema("collection", {
+      "type" => "array",
+      "items" => { "$ref" => "single.json" }
+    })
 
-    expect(response_for(["valid"])).to match_response_schema("array_schema")
+    valid_response = response_for([{foo: "is a string"}])
+    invalid_response = response_for([{foo: 0}])
+
+    expect(valid_response).to match_response_schema("collection")
+    expect(invalid_response).not_to match_response_schema("collection")
   end
 end

data/spec/spec_helper.rb

@@ -3,9 +3,7 @@ require "json/matchers"
 Dir["./spec/support/*"].each { |file| require file }
 
 RSpec.configure do |config|
-  config.include JSON::Matchers
   config.expect_with :rspec do |expectations|
-
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 

data/spec/support/file_helpers.rb

@@ -1,4 +1,6 @@
 module FileHelpers
+  ORIGINAL_SCHEMA_ROOT = JSON::Matchers.schema_root
+
   def create_schema(name, json)
     File.open("#{schema_root}/#{name}.json", "w") do |file|
       case json
@@ -29,13 +31,12 @@ RSpec.configure do |config|
   config.include FileHelpers
 
   config.around do |example|
-    original_schema_root = JSON::Matchers.schema_root
-    JSON::Matchers.schema_root = "#{Dir.pwd}/spec/fixtures/schemas"
+    JSON::Matchers.schema_root = File.join(Dir.pwd, "spec", "fixtures", "schemas")
     FileUtils.mkdir_p(JSON::Matchers.schema_root)
 
     example.run
 
     FileUtils.rm_rf(JSON::Matchers.schema_root)
-    JSON::Matchers.schema_root = original_schema_root
+    JSON::Matchers.schema_root = FileHelpers::ORIGINAL_SCHEMA_ROOT
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-matchers
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Sean Doyle
@@ -114,10 +114,8 @@ files:
 - lib/json/matchers/errors.rb
 - lib/json/matchers/matcher.rb
 - lib/json/matchers/rspec.rb
-- lib/json/matchers/schema_parser.rb
 - lib/json/matchers/version.rb
 - spec/json/matchers/match_response_schema_spec.rb
-- spec/json/matchers/schema_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/file_helpers.rb
 homepage: https://github.com/seanpdoyle/json-matchers
@@ -146,7 +144,6 @@ specification_version: 4
 summary: Validate your Rails JSON API's JSON
 test_files:
 - spec/json/matchers/match_response_schema_spec.rb
-- spec/json/matchers/schema_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/file_helpers.rb
 has_rdoc: 

data/lib/json/matchers/schema_parser.rb

@@ -1,22 +0,0 @@
-module JSON
-  module Matchers
-    class SchemaParser
-
-      attr_reader :schema_path
-
-      def initialize(schema_path)
-        @schema_path = Pathname(schema_path)
-      end
-
-      def schema_for(schema_name)
-        file = schema_path.join("#{schema_name}.json")
-
-        if file.exist?
-          ERB.new(file.read).result(binding)
-        else
-          raise MissingSchema, file.to_s
-        end
-      end
-    end
-  end
-end

data/spec/json/matchers/schema_parser_spec.rb

@@ -1,68 +0,0 @@
-require "json/matchers/schema_parser"
-
-describe JSON::Matchers::SchemaParser do
-  describe "#schema_for" do
-    it "returns the JSON string for a given schema" do
-      create_schema("foo", { type: "array" })
-
-      schema_parser = JSON::Matchers::SchemaParser.new(schema_root)
-
-      expect(schema_parser.schema_for("foo")).to eq '{"type":"array"}'
-    end
-
-    it "can embed other schemas" do
-      create_schema "post", <<-JSON.strip
-      {
-        "type": "object",
-        "required": ["id", "title", "body"],
-        "properties": {
-          "id": { "type": "integer" },
-          "title": { "type": "string" },
-          "body": { "type": "string" }
-        }
-      }
-      JSON
-      create_schema "posts", <<-JSON.strip
-      {
-        "type": "object",
-        "required": ["posts"],
-        "properties": {
-          "posts": {
-            "type": "array",
-            "items": <%= schema_for("post") %>
-          }
-        }
-      }
-      JSON
-
-      schema_parser = JSON::Matchers::SchemaParser.new(schema_root)
-      schema = schema_parser.schema_for("posts")
-
-      expect(JSON.parse(schema)).to eq({
-        "type" => "object",
-        "required" => ["posts"],
-        "properties" => {
-          "posts" => {
-            "type" => "array",
-            "items" => {
-              "type" => "object",
-              "required" => ["id", "title", "body"],
-              "properties" => {
-                "id" => { "type" => "integer" },
-                "title" => { "type" => "string" },
-                "body" => { "type" => "string" }
-              }
-            }
-          }
-        }
-      })
-    end
-
-    it "fails when the schema is missing" do
-      schema_parser = JSON::Matchers::SchemaParser.new(schema_root)
-      expect {
-        schema_parser.schema_for("missing")
-      }.to raise_error(JSON::Matchers::MissingSchema, /missing.json/)
-    end
-  end
-end