rspec_structure_matcher 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23536c95ca641e9f03faa3c2c7ba193ba9415b94
-  data.tar.gz: 40b064c9a9cc9944b61eddf7f1628476dca36a2e
+  metadata.gz: 8f4c12a199c9b2b9e255d25a96ddf3d60ae7f776
+  data.tar.gz: d80fe7b3b712eff665815bb6e8bf7783b2143d33
 SHA512:
-  metadata.gz: 0c2bb37e65de516a48748c6c1d0827471a71768db21fe201509d207f24118393dd0504ddd8a2f45c721b92ee09dae220a75692661c37a969d5994db2f55abc3b
-  data.tar.gz: d001136a60f227e531825d8897f6c7b9e5611ba18bfd4d34b1963c58678e9457b8bef6216b5843b4efc3a5b20838911ce66b1019f78eb3b9296e58d091d9f19b
+  metadata.gz: c15985b65931ab5a1653f4439f4c9af78407d3cb007c5fb53f601c29dc9d68ee711794d3db19ed6df06e7cc6d562aaa9cb654b773ae0c2cfaffc2f2d3b92a33b
+  data.tar.gz: c9c2f33e1d0d7f0f69ae2a30717c343d21bfaeef64203f4c58e7561db59a3fb15a40bb057c81b00dd95b5463242c9c14b08fac4ab41d5004aed62543ad60cc54

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/README.md

@@ -2,7 +2,7 @@
 
 A simple JSON structure matcher for RSpec.
 
-When building an API it is nice to be able to test the response structure. Doing this with the built-in RSpec matchers can get tiresome. This matcher provides a nicer way to test for expected keys, value types, and even matching values against regular expressions.
+When building an API it is nice to be able to test the response structure. Doing this with the built-in RSpec matchers can get tiresome. This matcher provides a nicer way to test for expected keys, value types, regular expressions, or custom validation procs/lambdas.
 
 ## Installation
 
@@ -23,11 +23,11 @@ Or install it yourself as:
 Define an expected response structure:
 
     expected_video_response = {
-      title: String,
-      episode_number: Object, # Optional, may be null
+      title: 'Top Gear', # Exact match
+      episode_number: optionally(Fixnum), # Optional, may be null
       tv_show: Hash,
       published_on: /\d{4}-\d{2}-\d{2}/,
-      breadcrumbs: Array,
+      breadcrumbs: ->(value) { value == 'bread/crumbs' },
       images: Hash
     }
 
@@ -42,31 +42,33 @@ Including an item in the expected structure ensures that a key with that name ex
 Native Types (String, Hash, etc.)
 : Test that the value matches the type, using `is_a?`.
 
-Object
-: Useful for testing the key exists but not requiring an particular type. Optional values (which are `null` if they are not present) can use this as well.
-
 Regular Expression
 : Tests the value for a match against the regular expression. Very useful for things like dates where your code is relying on a particular format.
 
-### Testing Optional Values
+Callable proc/lambda
+: Callback your supplied proc with the `actual_value`. Return `true` for a match and `false` for a failure.
 
-As mentioned above, you can use `Object` to test optional values, so that the test will pass even if the response contains a `null`. To add an extra level of checking you can use the `optionally_be` matcher:
+Exact match
+: Other values will be compared directly with `==`.
 
-    expect(video['episode_number']).to optionally_be(Integer)
+### Testing Optional Values
 
-This will pass if `video['episode_number']` is either `null` or `is_a?(Integer)`.
+As mentioned above, you can use `optionally` to test optional values, so that the test will pass even if the response contains a `null`. `optionally` is nothing more than a helpful lambda generation method, much like the proc/lambda that you can write yourself.
 
 ### Deep Structures
 
-Similar to optional values, testing deep strucutres has been kept as simple as possible. Simply define a new expected structure:
+Nesting deeper structures works automatically. Simply nest your structure:
 
-    tv_show_expected_structure = {
-      title: String
+    expected_video_response = {
+      title: 'Episode 1',
+      tv_show: {
+        title: 'Top Gear'
+      }
     }
 
 And then compare the structure as normal:
 
-    expect(video['tv_show']).to have_structure(tv_show_expected_structure)
+    expect(video).to have_structure(expected_video_response)
 
 ## Contributing
 

data/lib/have_structure_matcher.rb

@@ -1,38 +1,15 @@
+require 'pp'
+
 RSpec::Matchers.define :have_structure do |expected, opts|
   match do |actual|
-    invalid_items(actual, expected).empty?
+    HaveStructureMatcher.match?(actual, expected)
   end
 
   failure_message do |actual|
-    invalid = invalid_items(actual, expected)
-    "missing or invalid keys: #{invalid.keys.join(', ')}\n\n#{invalid}"
-  end
-
-  def invalid_items(actual, expected)
-    expected.each_with_object({}) do |(key, value), memo|
-      if !has_key?(actual, key) || !value_match(get_key(actual, key), value)
-        memo[key] = value
-      end
-    end
-  end
-
-  def has_key?(actual, key)
-    actual.key?(key.to_s) || actual.key?(key.to_sym)
-  end
-
-  def get_key(actual, key)
-    if actual.key?(key.to_s)
-      actual[key.to_s]
-    else
-      actual[key.to_sym]
-    end
-  end
-
-  def value_match(actual_value, expected_value)
-    if expected_value.is_a?(Regexp)
-      actual_value =~ expected_value
-    else
-      actual_value.is_a?(expected_value)
-    end
+    differ = RSpec::Support::Differ.new(color: RSpec::Matchers.configuration.color?)
+    differ.diff(
+      actual.pretty_inspect,
+      HaveStructureMatcher.build_diff(actual, expected).pretty_inspect
+    )
   end
 end

data/lib/rspec_structure_matcher.rb

@@ -1,2 +1,2 @@
+require 'support_methods'
 require 'have_structure_matcher'
-require 'optionally_be_matcher'

data/lib/support_methods.rb

@@ -0,0 +1,61 @@
+module HaveStructureMatcher
+  module Methods
+    def optionally(optional_expected_value)
+      ->(actual_value) { actual_value.nil? || HaveStructureMatcher.match?(actual_value, optional_expected_value) }
+    end
+  end
+
+  def self.match?(actual, expected)
+    actual == build_diff(actual, expected)
+  end
+
+  def self.build_diff(actual, expected)
+    return expected unless actual.is_a?(Hash)
+
+    keys = actual.keys | expected.keys
+
+    keys.each_with_object({}) do |key, memo|
+      if actual.key?(key) && expected.key?(key)
+        actual_value = actual[key]
+        expected_value = expected[key]
+
+        if expected_value.is_a?(Hash)
+          memo[key] = build_diff(actual_value, expected_value)
+        elsif expected_value.is_a?(Array)
+          memo[key] = expected_value.zip(actual_value).map { |(e,a)| build_diff(a, e) }
+        elsif value_match?(actual_value, expected_value)
+          memo[key] = actual_value
+        else
+          memo[key] = print_expected_value(expected_value)
+        end
+      elsif expected.key?(key)
+        expected_value = expected[key]
+        memo[key] = print_expected_value(expected_value)
+      end
+    end
+  end
+
+  def self.print_expected_value(expected_value)
+    if expected_value.respond_to?(:call)
+      "Proc [#{expected_value.source_location.join(':')}]"
+    else
+      expected_value
+    end
+  end
+
+  def self.value_match?(actual_value, expected_value)
+    if expected_value.is_a?(Regexp)
+      actual_value =~ expected_value
+    elsif expected_value.is_a?(Class)
+      actual_value.is_a?(expected_value)
+    elsif expected_value.respond_to?(:call)
+      expected_value.call(actual_value)
+    else
+      actual_value == expected_value
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include HaveStructureMatcher::Methods
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module RspecStructureMatcher
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/rspec_structure_matcher.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry-byebug"
 end

data/spec/lib/have_structure_matcher_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'rspec_structure_matcher'
 
 describe 'have_structure' do
@@ -18,7 +19,23 @@ describe 'have_structure' do
     it 'raises the correct error' do
       expect {
         expect(structure).to have_structure(expected_structure)
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /missing or invalid keys: bar/)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /-"bar" => String/)
+    end
+  end
+
+  context 'when there too many keys' do
+    let(:structure) {
+      {
+        'foo' => 'baz',
+        'bar' => 'baz',
+        'bam' => 'baz'
+      }
+    }
+
+    it 'raises the correct error' do
+      expect {
+        expect(structure).to have_structure(expected_structure)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /\+"bam" => "baz"/)
     end
   end
 
@@ -33,7 +50,7 @@ describe 'have_structure' do
     it 'raises the correct error' do
       expect {
         expect(structure).to have_structure(expected_structure)
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /missing or invalid keys: foo/)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /-"foo" => String/)
     end
   end
 
@@ -60,10 +77,151 @@ describe 'have_structure' do
       }
     }
 
-    it 'raise no error' do
+    it 'fails validation' do
       expect {
         expect(structure).to have_structure(expected_structure)
-      }.not_to raise_error
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /-"foo" => String/)
+    end
+  end
+
+  context 'matching exact values' do
+    let(:structure) do
+      {
+        'foo' => 1,
+        'bar' => 'baz'
+      }
+    end
+
+    context 'with correct values' do
+      let(:expected_structure) do
+        {
+          'foo' => 1,
+          'bar' => 'baz'
+        }
+      end
+
+      it 'raise no error' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.not_to raise_error
+      end
     end
+
+    context 'with incorrect values' do
+      let(:expected_structure) do
+        {
+          'foo' => 2,
+          'bar' => 'baz'
+        }
+      end
+
+      it 'fails validation' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /-"foo" => 2/)
+      end
+    end
+  end
+
+  context 'matching with procs' do
+    let(:test_lambda) { ->(actual_value) { actual_value == 'baz' } }
+
+    let(:expected_structure) do
+      {
+        'foo' => test_lambda
+      }
+    end
+
+    context 'correct value' do
+      let(:structure) { {'foo' => 'baz'} }
+
+      it 'raise no error' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.not_to raise_error
+      end
+    end
+
+    context 'incorrect value' do
+      let(:structure) { {'foo' => 100} }
+
+      it 'fails validation' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /\+"foo" => 100/)
+      end
+    end
+  end
+
+  context "matching with 'optionally' helper method" do
+    let(:expected_structure) do
+      {
+        'foo' => optionally(2)
+      }
+    end
+
+    context 'correct value' do
+      let(:structure) { {'foo' => 2} }
+
+      it 'raise no error' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.not_to raise_error
+      end
+    end
+
+    context 'null value' do
+      let(:structure) { {'foo' => nil} }
+
+      it 'raise no error' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.not_to raise_error
+      end
+    end
+  end
+
+  context "with nested structure" do
+    let(:expected_structure) do
+      {
+        'foo' => 1,
+        'bar' => {
+          'baz' => String
+        }
+      }
+    end
+
+    context "matches correctly" do
+      let(:structure) do
+        {
+          'foo' => 1,
+          'bar' => {
+            'baz' => 'hello'
+          }
+        }
+      end
+
+      it 'passes validation' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.not_to raise_error
+      end
+    end
+
+    context "mis-matched nesting" do
+      let(:structure) do
+        {
+          'foo' => 1,
+          'bar' => 'a'
+        }
+      end
+
+      it 'fails validation' do
+        expect {
+          expect(structure).to have_structure(expected_structure)
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /\+"bar" => "a"/)
+      end
+    end
+
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "bundler/setup"
+Bundler.setup
+
+require "pry-byebug"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec_structure_matcher
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Tony Marklove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rspec matchers for structured JSON responses. Compare expected keys,
   value types, or even match values against regular expressions.
 email:
@@ -61,16 +75,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".ruby-version"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/have_structure_matcher.rb
-- lib/optionally_be_matcher.rb
 - lib/rspec_structure_matcher.rb
+- lib/support_methods.rb
 - lib/version.rb
 - rspec_structure_matcher.gemspec
 - spec/lib/have_structure_matcher_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/jjbananas/rspec_structure_matcher
 licenses:
 - MIT
@@ -91,9 +108,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Rspec matchers for structured JSON responses.
 test_files:
 - spec/lib/have_structure_matcher_spec.rb
+- spec/spec_helper.rb

data/lib/optionally_be_matcher.rb

@@ -1,9 +0,0 @@
-RSpec::Matchers.define :optionally_be do |expected|
-  match do |actual|
-    actual.nil? || actual.is_a?(expected)
-  end
-
-  failure_message do |actual|
-    "#{actual} must be 'nil' or '#{expected}'"
-  end
-end