jsontest 1.0.0

data/spec/jsontest/matchers/be_json_eql_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe JsonTest::Matchers::BeJsonEql do
+  it "matches identical JSON" do
+    %({"json":"spec"}).should be_json_eql(%({"json":"spec"}))
+  end
+
+  it "matches differently-formatted JSON" do
+    %({"json": "spec"}).should be_json_eql(%({"json":"spec"}))
+  end
+
+  it "matches out-of-order hashes" do
+    %({"laser":"lemon","json":"spec"}).should be_json_eql(%({"json":"spec","laser":"lemon"}))
+  end
+
+  it "doesn't match out-of-order arrays" do
+    %(["json","spec"]).should_not be_json_eql(%(["spec","json"]))
+  end
+
+  it "matches valid JSON values, yet invalid JSON documents" do
+    %("jsontest").should be_json_eql(%("jsontest"))
+  end
+
+  it "matches at a path" do
+    %({"json":["spec"]}).should be_json_eql(%("spec")).at_path("json/0")
+  end
+
+  it "ignores excluded-by-default hash keys" do
+    JsonTest.excluded_keys.should_not be_empty
+
+    actual = expected = { "json" => "spec" }
+    JsonTest.excluded_keys.each { |k| actual[k] = k }
+    actual.to_json.should be_json_eql(expected.to_json)
+  end
+
+  it "ignores custom excluded hash keys" do
+    JsonTest.exclude_keys("ignore")
+    %({"json":"spec","ignore":"please"}).should be_json_eql(%({"json":"spec"}))
+  end
+
+  it "ignores nested, excluded hash keys" do
+    JsonTest.exclude_keys("ignore")
+    %({"json":"spec","please":{"ignore":"this"}}).should be_json_eql(%({"json":"spec","please":{}}))
+  end
+
+  it "ignores hash keys when included in the expected value" do
+    JsonTest.exclude_keys("ignore")
+    %({"json":"spec","ignore":"please"}).should be_json_eql(%({"json":"spec","ignore":"this"}))
+  end
+
+  it "doesn't match Ruby-equivalent, JSON-inequivalent values" do
+    %({"one":1}).should_not be_json_eql(%({"one":1.0}))
+  end
+
+  it "matches different looking, JSON-equivalent values" do
+    %({"ten":10.0}).should be_json_eql(%({"ten":1e+1}))
+  end
+
+  it "excludes extra hash keys per matcher" do
+    JsonTest.excluded_keys = %w(ignore)
+    %({"id":1,"json":"spec","ignore":"please"}).should be_json_eql(%({"id":2,"json":"spec","ignore":"this"})).excluding("id")
+  end
+
+  it "excludes extra hash keys given as symbols" do
+    JsonTest.excluded_keys = []
+    %({"id":1,"json":"spec"}).should be_json_eql(%({"id":2,"json":"spec"})).excluding(:id)
+  end
+
+  it "excludes multiple keys" do
+    JsonTest.excluded_keys = []
+    %({"id":1,"json":"spec"}).should be_json_eql(%({"id":2,"json":"different"})).excluding(:id, :json)
+  end
+
+  it "includes globally-excluded hash keys per matcher" do
+    JsonTest.excluded_keys = %w(id ignore)
+    %({"id":1,"json":"spec","ignore":"please"}).should_not be_json_eql(%({"id":2,"json":"spec","ignore":"this"})).including("id")
+  end
+
+  it "includes globally-included hash keys given as symbols" do
+    JsonTest.excluded_keys = %w(id)
+    %({"id":1,"json":"spec"}).should_not be_json_eql(%({"id":2,"json":"spec"})).including(:id)
+  end
+
+  it "includes multiple keys" do
+    JsonTest.excluded_keys = %w(id json)
+    %({"id":1,"json":"spec"}).should_not be_json_eql(%({"id":2,"json":"different"})).including(:id, :json)
+  end
+
+  it "provides a description message" do
+    matcher = be_json_eql(%({"id":2,"json":"spec"}))
+    matcher.matches?(%({"id":1,"json":"spec"}))
+    matcher.description.should == "equal JSON"
+  end
+
+  it "provides a description message with path" do
+    matcher = be_json_eql(%({"id":1,"json":["spec"]})).at_path("json/0")
+    matcher.matches?(%({"id":1,"json":["spec"]}))
+    matcher.description.should == %(equal JSON at path "json/0")
+  end
+
+  it "raises an error when not given expected JSON" do
+    expect{ %({"id":1,"json":"spec"}).should be_json_eql }.to raise_error do |error|
+      error.message.should == "Expected equivalent JSON not provided"
+    end
+  end
+
+  it "matches file contents" do
+    JsonTest.directory = files_path
+    %({ "value" : "from_file" }).should be_json_eql.to_file("one.json")
+  end
+end

data/spec/jsontest/matchers/have_json_path_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe JsonTest::Matchers::HaveJsonPath do
+  it "matches hash keys" do
+    %({"one":{"two":{"three":4}}}).should have_json_path("one/two/three")
+  end
+
+  it "doesn't match values" do
+    %({"one":{"two":{"three":4}}}).should_not have_json_path("one/two/three/4")
+  end
+
+  it "matches array indexes" do
+    %([1,[1,2,[1,2,3,4]]]).should have_json_path("1/2/3")
+  end
+
+  it "respects null array values" do
+    %([null,[null,null,[null,null,null,null]]]).should have_json_path("1/2/3")
+  end
+
+  it "matches hash keys and array indexes" do
+    %({"one":[1,2,{"three":4}]}).should have_json_path("one/2/three")
+  end
+
+  it "provides a description message" do
+    matcher = have_json_path("json")
+    matcher.matches?(%({"id":1,"json":"spec"}))
+    matcher.description.should == %(have JSON path "json")
+  end
+end

data/spec/jsontest/matchers/have_json_size_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe JsonTest::Matchers::HaveJsonSize do
+  it "counts array entries" do
+    %([1,2,3]).should have_json_size(3)
+  end
+
+  it "counts null array entries" do
+    %([1,null,3]).should have_json_size(3)
+  end
+
+  it "counts hash key/value pairs" do
+    %({"one":1,"two":2,"three":3}).should have_json_size(3)
+  end
+
+  it "counts null hash values" do
+    %({"one":1,"two":null,"three":3}).should have_json_size(3)
+  end
+
+  it "matches at a path" do
+    %({"one":[1,2,3]}).should have_json_size(3).at_path("one")
+  end
+
+  it "provides a failure message" do
+    matcher = have_json_size(3)
+    matcher.matches?(%([1,2]))
+    matcher.failure_message.should            eq "Expected JSON value size to be 3, got 2"
+    matcher.failure_message_for_should.should eq "Expected JSON value size to be 3, got 2" # RSpec 2 interface
+  end
+
+  it "provides a failure message for negation" do
+    matcher = have_json_size(3)
+    matcher.matches?(%([1,2,3]))
+    matcher.failure_message_when_negated.should   eq "Expected JSON value size to not be 3, got 3"
+    matcher.failure_message_for_should_not.should eq "Expected JSON value size to not be 3, got 3" # RSpec 2 interface
+  end
+
+  it "provides a description message" do
+    matcher = have_json_size(1)
+    matcher.matches?(%({"id":1,"json":["spec"]}))
+    matcher.description.should eq %(have JSON size "1")
+  end
+
+  it "provides a description message with path" do
+    matcher = have_json_size(1).at_path("json")
+    matcher.matches?(%({"id":1,"json":["spec"]}))
+    matcher.description.should eq %(have JSON size "1" at path "json")
+  end
+
+  it "provides an error when parsing nil" do
+    matcher = have_json_size(0).at_path("json")
+    expect { matcher.matches?(%({"id":1,"json":null})) }.to raise_error(JsonTest::EnumerableExpected,
+                                                                          "Enumerable expected, got nil")
+  end
+
+  it "provides an error when parsing non-enumerables" do
+    matcher = have_json_size(0).at_path("json")
+    expect { matcher.matches?(%({"id":1,"json":12345})) }.to raise_error(JsonTest::EnumerableExpected,
+                                                                           "Enumerable expected, got 12345")
+  end
+end

data/spec/jsontest/matchers/have_json_type_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe JsonTest::Matchers::HaveJsonType do
+  it "matches hashes" do
+    hash = %({})
+    hash.should have_json_type(Hash)
+    hash.should have_json_type(:object)
+  end
+
+  it "matches arrays" do
+    %([]).should have_json_type(Array)
+  end
+
+  it "matches at a path" do
+    %({"root":[]}).should have_json_type(Array).at_path("root")
+  end
+
+  it "matches strings" do
+    %(["jsontest"]).should have_json_type(String).at_path("0")
+  end
+
+  it "matches a valid JSON value, yet invalid JSON document" do
+    %("jsontest").should have_json_type(String)
+  end
+
+  it "matches empty strings" do
+    %("").should have_json_type(String)
+  end
+
+  it "matches integers" do
+    %(10).should have_json_type(Integer)
+  end
+
+  it "matches floats" do
+    %(10.0).should have_json_type(Float)
+    %(1e+1).should have_json_type(Float)
+  end
+
+  it "matches booleans" do
+    %(true).should have_json_type(:boolean)
+    %(false).should have_json_type(:boolean)
+  end
+
+  it "matches ancestor classes" do
+    %(10).should have_json_type(Numeric)
+    %(10.0).should have_json_type(Numeric)
+  end
+
+  it "provides a failure message" do
+    matcher = have_json_type(Numeric)
+    matcher.matches?(%("foo"))
+    matcher.failure_message.should            eq "Expected JSON value type to be Numeric, got String"
+    matcher.failure_message_for_should.should eq "Expected JSON value type to be Numeric, got String" # RSpec 2 interface
+  end
+
+  it "provides a failure message for negation" do
+    matcher = have_json_type(Numeric)
+    matcher.matches?(%(10.0))
+
+    matcher.failure_message_when_negated.should   eq "Expected JSON value type to not be Numeric, got Float"
+    matcher.failure_message_for_should_not.should eq "Expected JSON value type to not be Numeric, got Float" # RSpec 2 interface
+  end
+
+  it "provides a description message" do
+    matcher = have_json_type(String)
+    matcher.matches?(%({"id":1,"json":"spec"}))
+    matcher.description.should eq %(have JSON type "String")
+  end
+
+  it "provides a description message with path" do
+    matcher = have_json_type(String).at_path("json")
+    matcher.matches?(%({"id":1,"json":"spec"}))
+    matcher.description.should eq %(have JSON type "String" at path "json")
+  end
+
+  context "somewhat uselessly" do
+    it "matches true" do
+      %(true).should have_json_type(TrueClass)
+    end
+
+    it "matches false" do
+      %(false).should have_json_type(FalseClass)
+    end
+
+    it "matches null" do
+      null = %(null)
+      null.should have_json_type(NilClass)
+      null.should have_json_type(:nil)
+      null.should have_json_type(:null)
+    end
+  end
+end

data/spec/jsontest/matchers/include_json_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe JsonTest::Matchers::IncludeJson do
+  it "matches included array elements" do
+    json = %(["one",1,1.0,true,false,null])
+    json.should include_json(%("one"))
+    json.should include_json(%(1))
+    json.should include_json(%(1.0))
+    json.should include_json(%(true))
+    json.should include_json(%(false))
+    json.should include_json(%(null))
+  end
+
+  it "matches an array included in an array" do
+    json = %([[1,2,3],[4,5,6]])
+    json.should include_json(%([1,2,3]))
+    json.should include_json(%([4,5,6]))
+  end
+
+  it "matches a hash included in an array" do
+    json = %([{"one":1},{"two":2}])
+    json.should include_json(%({"one":1}))
+    json.should include_json(%({"two":2}))
+  end
+
+  it "matches included hash values" do
+    json = %({"string":"one","integer":1,"float":1.0,"true":true,"false":false,"null":null})
+    json.should include_json(%("one"))
+    json.should include_json(%(1))
+    json.should include_json(%(1.0))
+    json.should include_json(%(true))
+    json.should include_json(%(false))
+    json.should include_json(%(null))
+  end
+
+  it "matches a hash included in a hash" do
+    json = %({"one":{"two":3},"four":{"five":6}})
+    json.should include_json(%({"two":3}))
+    json.should include_json(%({"five":6}))
+  end
+
+  it "matches an array included in a hash" do
+    json = %({"one":[2,3],"four":[5,6]})
+    json.should include_json(%([2,3]))
+    json.should include_json(%([5,6]))
+  end
+
+  it "matches a substring" do
+    json = %("json")
+    json.should include_json(%("js"))
+    json.should include_json(%("json"))
+  end
+
+  it "matches at a path" do
+    %({"one":{"two":[3,4]}}).should include_json(%([3,4])).at_path("one")
+  end
+
+  it "ignores excluded keys" do
+    %([{"id":1,"two":3}]).should include_json(%({"two":3}))
+  end
+
+  it "provides a description message" do
+    matcher = include_json(%({"json":"spec"}))
+    matcher.matches?(%({"id":1,"json":"spec"}))
+    matcher.description.should == "include JSON"
+  end
+
+  it "provides a description message with path" do
+    matcher = include_json(%("spec")).at_path("json/0")
+    matcher.matches?(%({"id":1,"json":["spec"]}))
+    matcher.description.should == %(include JSON at path "json/0")
+  end
+
+  it "provides a useful failure message for should" do
+    matcher = include_json(%([4,5,6]))
+    matcher.matches?(%([1,2,3]))
+    matcher.failure_message_for_should.should == "Expected [1,2,3] to include [4,5,6]"
+  end
+
+  it "provides a useful failure message for should not" do
+    matcher = include_json(%(3))
+    matcher.matches?(%([1,2,3]))
+    matcher.failure_message_for_should_not.should == "Expected [1,2,3] to not include 3"
+  end
+
+  it "raises an error when not given expected JSON" do
+    expect{ %([{"id":1,"two":3}]).should include_json }.to raise_error do |error|
+      error.message.should == "Expected included JSON not provided"
+    end
+  end
+
+  it "matches file contents" do
+    JsonTest.directory = files_path
+    %({"one":{"value":"from_file"},"four":{"five":6}}).should include_json.from_file("one.json")
+  end
+end

data/spec/jsontest/matchers_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe JsonTest::Matchers do
+  let(:environment) do
+    klass = Class.new
+    klass.send(:include, JsonTest::Matchers)
+    klass.new
+  end
+
+  let(:json){ %({"json":"spec"}) }
+
+  context "be_json_eql" do
+    it "instantiates its matcher" do
+      JsonTest::Matchers::BeJsonEql.should_receive(:new).with(json)
+      environment.be_json_eql(json)
+    end
+
+    it "returns its matcher" do
+      matcher = environment.be_json_eql(json)
+      matcher.should be_a(JsonTest::Matchers::BeJsonEql)
+    end
+  end
+
+  context "include_json" do
+    it "instantiates its matcher" do
+      JsonTest::Matchers::IncludeJson.should_receive(:new).with(json)
+      environment.include_json(json)
+    end
+
+    it "returns its matcher" do
+      matcher = environment.include_json(json)
+      matcher.should be_a(JsonTest::Matchers::IncludeJson)
+    end
+  end
+
+  context "have_json_path" do
+    let(:path){ "json" }
+
+    it "instantiates its matcher" do
+      JsonTest::Matchers::HaveJsonPath.should_receive(:new).with(path)
+      environment.have_json_path(path)
+    end
+
+    it "returns its matcher" do
+      matcher = environment.have_json_path(path)
+      matcher.should be_a(JsonTest::Matchers::HaveJsonPath)
+    end
+  end
+
+  context "have_json_type" do
+    let(:type){ Hash }
+
+    it "instantiates its matcher" do
+      JsonTest::Matchers::HaveJsonType.should_receive(:new).with(type)
+      environment.have_json_type(type)
+    end
+
+    it "returns its matcher" do
+      matcher = environment.have_json_type(type)
+      matcher.should be_a(JsonTest::Matchers::HaveJsonType)
+    end
+  end
+
+  context "have_json_size" do
+    let(:size){ 1 }
+
+    it "instantiates its matcher" do
+      JsonTest::Matchers::HaveJsonSize.should_receive(:new).with(size)
+      environment.have_json_size(size)
+    end
+
+    it "returns its matcher" do
+      matcher = environment.have_json_size(size)
+      matcher.should be_a(JsonTest::Matchers::HaveJsonSize)
+    end
+  end
+end