rspec-api_helpers 0.2.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b793c8e8f7f6b2ac576475bbd5a388770374a396
-  data.tar.gz: e9b24e1f7035dc2c255d807aa21b7d71f86ffb55
+  metadata.gz: fc01855aa47f3e617fdfca911ccbf4aede2e50a3
+  data.tar.gz: 5db89416125336490daa28757862b0a74887dc86
 SHA512:
-  metadata.gz: dbb94217c3cd0dd3d6218aa3a5905f2581ff6b6d1b53c1957660d3d1e872234a7ac9c0dbd75ddbfa8cd45d4789e3e6e5ac7947d21e0c06d3feed2f198eb576e2
-  data.tar.gz: 5b7de73e53c6bddacff741325324824ab2a2ea2254af2ad964006f0809f8e74e93b33799a6635fe14ca0a4eaacd335432155a9580703db51e166751358135ee8
+  metadata.gz: 8b53bd402dd540f09d4b63e471f8bffa5e985a2b56e94ea4ed506c4c9eddbdb5dcd771a9bc378d23dfb7659239b6e5d408365a0509fd317e7701e9bdd097323a
+  data.tar.gz: dfb3344d4d964e568a399157e3587b15893b48d2ce29f3d8ad8ca274c2821b1df850683e52ba6468f5b0ba1c445f56ed44ec4e5e8c679a584864340a067e6ee4

data/README.md

@@ -1,6 +1,6 @@
 # Rspec::ApiHelpers
 
-Usefull Rspec helpers for APIs (currently only ActiveModel Serializers are supported)
+Usefull Rspec helpers for APIs (currently JSONAPI and AM-JSON adapters are supported)
 
 ## Installation
 
@@ -29,43 +29,122 @@ In your `rails_helper.rb` add in the top:
 require 'rspec/api_helpers'
 ```
 
-and then you only need to include the helpers in your rspec examples. You can include them on all api (:type => :api) helpers by adding the following line in your rspec config:
+Then you need to specify the adapter you want.
 
 ```ruby
-  config.include Rspec::ApiHelpers, type: :api
+RSpec.configure do |config|
+  config.include Rspec::ApiHelpers.with(adapter: :json_api)
+end
 ```
+Other possible options for the adapter is `active_model`.
 
+You can also inject your custom made class by providing the class:
+```ruby
+RSpec.configure do |config|
+  config.include Rspec::ApiHelpers.with(adapter: Adapter::Hal)
+end
+```
 
 ### Examples
+The library heavily uses dynamic scopes through procs (an alternative to eval).
+
+
+#### General
 
 ```ruby
 it_returns_status(200)
 ```
-It checks if the HTTP response status is 200.
+It expects the HTTP response status to be 200.
 
 ```ruby
-it_returns_attributes(resource: 'user', model: '@user', only: [
+it_includes_in_headers('SESSION_TOKEN' => proc{@user.token})
+```
+It expects the HTTP response to include this header (and value).
+
+#### Resource
+
+```ruby
+it_returns_attributes(resource: 'user', model: '@user', attrs: [
   :email, :name
 ])
 ```
-It checks if the HTTP body contains an AMS json that has :email and :name attributes and
-compares them with '@user' variable's attributes.
+
+It expects the JSON resource to contain :email and :name attributes and
+be equal with with `@user` methods.
+
+
+```ruby
+it_returns_attribute_values(
+  resource: 'user', model: proc{@user}, attrs: [
+    :id, :name, :email, :admin, :activated, :created_at, :updated_at
+  ], modifiers: {
+    [:created_at, :updated_at] => proc{|i| i.iso8601},
+    :id => proc{|i| i.to_s}
+  }
+)
+```
+It expects the JSON resource to contain specific attribute values as above but for
+`:updated_at`, `:created_at` and `id` it applies specific methods first, defined in the
+`modifier` hash (note that the methods are applied in the JSON resource, not in the variable)
+
+```ruby
+it_returns_no_attributes(
+  resource: 'user', attrs: [:foo1, :foo2, :foo3]
+)
+```
+It expects the JSON resource to NOT contain any of those attributes.
+
+#### Collection
+```ruby
+it_returns_collection_size(resource: 'users', size: 6)
+```
+
+It expects the JSON collection to have `6` resources.
 
 ```ruby
-it_returns_more_attributes(
-  resource: 'user',
-  model: 'User.last!',
-  only: [:updated_at, :created_at],
-  modifier: 'iso8601'
+it_returns_collection_attributes(
+  resource: 'users', attrs: [
+    :id, :name, :email, :admin, :activated, :created_at, :updated_at
+  ]
 )
 ```
-It checks if the HTTP body contains an AMS json that has :updated_at and :created_at
-attributes and compares them with '@user' variable's attributes after it applies modifier.
+
+It expects the JSON collection to have those attributes (no value checking).
+
 
 ```ruby
-it_returns_resources(root: 'users', number: 5)
+it_returns_no_collection_attributes(
+  resource: 'users', attrs: [
+    :foo
+  ]
+)
 ```
-It checks if the HTTP body contains an AMS json with an array of 'users'.
+
+It expects the JSON collection NOT to have those attributes (no value checking).
+
+
+```ruby
+it_returns_collection_attribute_values(
+  resource: 'users', model: proc{User.first!}, attrs: [
+    :id, :name, :email, :admin, :activated, :created_at, :updated_at
+  ], modifiers: {
+    [:created_at, :updated_at] => proc{|i| i.iso8601},
+    :id => proc{|i| i.to_s}
+  }
+)
+```
+
+It expects the JSON collection to contain specific attribute values as above but for
+`:updated_at`, `:created_at` and `id` it applies specific methods first, defined in the
+`modifier` hash (note that the methods are applied in the JSON resource, not in the variable)
+
+
+## To Do
+* Enhance documentation
+* Better dir structure (break example group methods to modules)
+* Support for nested resources
+* Add tests
+* Support for HAL/Siren adapter
 
 ## Contributing
 

data/lib/rspec/api_helpers.rb

@@ -1,12 +1,33 @@
 require 'rspec/api_helpers/version'
+require 'rspec/api_helpers/dispatcher'
 require 'rspec/api_helpers/example_methods'
 require 'rspec/api_helpers/example_group_methods'
 
 module Rspec
+
   module ApiHelpers
+    class << self;
+      attr_accessor :adapter
+    end
+
     def self.included(receiver)
       receiver.extend         ExampleGroupMethods
       receiver.send :include, ExampleMethods
     end
+
+    def self.with(adapter:)
+      if adapter.is_a?(Class)
+        self.adapter = adapter
+      else
+        case adapter.to_s.to_sym
+        when :active_model
+          self.adapter = Adapter::ActiveModel
+        when :json_api
+          self.adapter = Adapter::JsonApi
+        end
+      end
+
+      return self
+    end
   end
 end

data/lib/rspec/api_helpers/adapter/active_model/adapter.rb

@@ -0,0 +1,19 @@
+class Adapter
+  class ActiveModel
+    include RSpec::Matchers
+
+    class << self
+      def resource(options, response, _binding)
+        hashed_response = HashWithIndifferentAccess.new(JSON.parse(response.body))
+
+        return Resource.new(options, hashed_response, _binding)
+      end
+
+      def collection(options, response, _binding)
+        hashed_response = HashWithIndifferentAccess.new(JSON.parse(response.body))
+
+        return Collection.new(options, hashed_response, _binding)
+      end
+    end
+  end
+end

data/lib/rspec/api_helpers/adapter/active_model/collection.rb

@@ -0,0 +1,46 @@
+class Adapter::ActiveModel::Collection
+  include Adapter::ActiveModel::CommonHelpers
+  include RSpec::Matchers
+
+  def initialize(options, response, _binding)
+    @options = HashWithIndifferentAccess.new(options)
+    @response = response
+    @_binding = _binding
+  end
+
+  def has_size(size)
+    expect(collection.size).to(eq size)
+  end
+
+  def sample(new_options = {})
+    Adapter::ActiveModel::Resource.new(
+      options.merge(new_options), collection.sample.hash, @_binding
+    )
+  end
+
+  def find_by(id, new_options = {})
+    resource = collection.find{|i| i.send(id).to_s == model.send(id).to_s}
+    if resource.nil?
+      raise "Resource was not found for id: #{id} (model value: #{model.send(id)})"
+    end
+
+    return Adapter::ActiveModel::Resource.new(
+      options.merge(new_options), resource.hash, @_binding
+    )
+  end
+
+  private
+    attr_reader :options
+
+    def model
+      @model ||= parse_model(
+        @_binding.instance_exec(&options[:model])
+      )
+    end
+
+    def collection
+      @collection ||= objectize_collection(
+        @response, root: options[:resource]
+      )
+    end
+end

data/lib/rspec/api_helpers/adapter/active_model/common_helpers.rb

@@ -0,0 +1,74 @@
+module Adapter::ActiveModel::CommonHelpers
+  def objectize_collection(collection, root: nil, existing: true)
+    if root
+      collection = collection[root]
+    end
+
+    return collection.map{|resource|
+      object_hash(resource, existing: existing)
+    }
+  end
+
+  def objectize_resource(resource, root: nil, existing: true)
+    if root
+      obj = object_hash(resource[root], existing: existing)
+    else
+      obj = object_hash(resource, existing: existing)
+    end
+
+    return obj
+  end
+
+  def object_hash(hash, existing: true)
+    ObjectHash.new(hash, existing: existing)
+  end
+
+  class ObjectHash
+    #existing denotes whether we search for attributes that exist on the
+    #resource or attributes that shouldn't exist
+    attr_accessor :hash, :existing
+    def initialize(hash, existing: true)
+      @hash = HashWithIndifferentAccess.new(hash)
+      @existing = existing
+    end
+
+    def method_missing(name)
+      if existing
+        if hash.key?(name)
+          return hash[name]
+        else
+          return raise KeyError.new("Attribute not found in resource: #{name}")
+        end
+      else
+        if hash.key?(name)
+          return raise(
+            KeyError.new(
+              "Attribute found in resource when it shouldn't: #{name}"
+            )
+          )
+        else
+          return :attribute_not_found
+        end
+      end
+    end
+  end
+
+  def superset_mismatch_error(superset, subset)
+    "Expected \n #{subset.to_a.to_s} \n to be included in \n #{superset.to_a.to_s}"
+  end
+
+  def parse_model(model)
+    return model unless model.is_a? Hash
+    
+    return object_hash(model)
+  end
+
+  def modifier_for(key)
+    if modifiers_hash[key]
+      return modifiers_hash[key]
+    else
+      return proc{|i| i}
+    end
+  end
+
+end

data/lib/rspec/api_helpers/adapter/active_model/resource.rb

@@ -0,0 +1,77 @@
+class Adapter::ActiveModel::Resource
+  include Adapter::ActiveModel::CommonHelpers
+  include RSpec::Matchers
+
+  def initialize(options, response, _binding)
+    @options = HashWithIndifferentAccess.new(options)
+    @response = response
+    @_binding = _binding
+  end
+
+  def resource
+    @resource ||= objectize_resource(
+      @response, root: options[:resource], existing: options[:existing]
+    )
+  end
+
+  def compare_attribute(attribute)
+    expect(resource.send(attribute)).to(
+      eql(
+        modifier_for(attribute).call(
+          model.send(attribute)
+        )
+      )
+    )
+  end
+
+  def embedded_collection(new_options = {})
+    raise 'embeds option missing' unless (options[:embeds] || new_options[:embeds])
+
+    Adapter::ActiveModel::Collection.new(
+      options.merge(new_options), resource.send(options[:embeds]), @_binding
+    )
+  end
+
+  def has_no_attribute(attribute)
+    expect(resource.send(attribute)).to(eql(:attribute_not_found))
+  end
+
+  def has_attribute(attribute)
+    expect(resource.send(attribute)).to_not(eql(:attribute_not_found))
+  end
+
+  private
+    attr_reader :options
+
+    def model
+      raise 'model is missing' if options[:model].blank?
+
+      @model ||= parse_model(
+        @_binding.instance_exec(&options[:model])
+      )
+    end
+
+    def attrs
+      options[:attrs].map{|i| i.to_s}
+    end
+
+    def attrs?
+      attrs.any?
+    end
+
+    def modifiers_hash
+      return {} if options[:modifiers].blank?
+
+      @modifiers_hash = {}
+      options[:modifiers].each do |key, value|
+        [key].flatten.each do |attr|
+          if attrs?
+            raise "#{attr} missing from :attrs param" unless attrs.include?(attr.to_s)
+            @modifiers_hash[attr] = value
+          end
+        end
+      end
+
+      return @modifiers_hash
+    end
+end

data/lib/rspec/api_helpers/adapter/jsonapi/adapter.rb

@@ -0,0 +1,52 @@
+class Adapter
+  class JsonApi
+    include RSpec::Matchers
+
+    class << self
+      def resource(options, response, _binding)
+        jsonapi_resource = HashWithIndifferentAccess.new(JSON.parse(response.body))
+
+        jsonapi_resource = transform_resource(jsonapi_resource.dig('data') || {})
+
+        return Adapter::ActiveModel::Resource.new(options, jsonapi_resource, _binding)
+      end
+
+      def collection(options, response, _binding)
+        jsonapi_collection = HashWithIndifferentAccess.new(JSON.parse(response.body))
+
+        jsonapi_collection = transform_collection(jsonapi_collection.dig('data') || {})
+
+        return Adapter::ActiveModel::Collection.new(options, jsonapi_collection, _binding)
+      end
+
+
+      private
+        def transform_resource(jsonapi_hash, root: true)
+          type = jsonapi_hash.dig('type').singularize
+          json_hash = jsonapi_hash.dig('attributes').transform_keys{|key|
+            key.underscore
+          }.merge(id: jsonapi_hash.dig('id').to_s)
+
+          if root
+            return HashWithIndifferentAccess.new({type => json_hash})
+          else
+            return HashWithIndifferentAccess.new(json_hash)
+          end
+        end
+
+        def transform_collection(jsonapi_hash, root: true)
+          type = jsonapi_hash.first.dig('type').pluralize
+
+          json_hash = jsonapi_hash.map{|data|
+            transform_resource(data, root: false)
+          }
+
+          if root
+            return HashWithIndifferentAccess.new({type => json_hash})
+          else
+            return json_hash
+          end
+        end
+    end
+  end
+end

data/lib/rspec/api_helpers/dispatcher.rb

@@ -0,0 +1,16 @@
+require 'rspec/api_helpers/adapter/jsonapi/adapter'
+require 'rspec/api_helpers/adapter/active_model/adapter'
+require 'rspec/api_helpers/adapter/active_model/common_helpers'
+require 'rspec/api_helpers/adapter/active_model/resource'
+require 'rspec/api_helpers/adapter/active_model/collection'
+
+
+module Rspec
+  module ApiHelpers
+    class Dispatcher
+      def adapter
+        Rspec::ApiHelpers.adapter
+      end
+    end
+  end
+end

data/lib/rspec/api_helpers/example_group_methods.rb

@@ -7,56 +7,23 @@ module Rspec
         end
       end
 
-      def it_returns_attribute_values(resource:, model:, only: [], modifier: {})
-        it "expects returned resource (#{resource}) to have model attribute values" do
-          api_resource = objectize_resource(last_response.body, root: resource)
-
-          modifier = HashWithIndifferentAccess.new(modifier)
-
-          model = eval(model)
-          if model.is_a? Hash
-            model = object_hash(model)
-          end
-
-          if only
-            only.each do |attribute|
-              begin
-                if modifier.has_key?(attribute)
-                  modifier[attribute] = [modifier[attribute]].flatten
-
-                  expect(api_resource.send(attribute)).to(
-                    eql(
-                      modifier[attribute].inject(
-                        model.send(attribute), :send
-                      )
-                    )
-                  )
-                else
-                  expect(api_resource.send(attribute)).to(
-                    eql(model.send(attribute))
-                  )
-                end
-              rescue RSpec::Expectations::ExpectationNotMetError => e
-                e.message << "failed at model attribute: #{attribute}"
-                raise e
-              end
-            end
+      #make rehashable
+      def it_includes_in_headers(headers = {})
+        headers.each do |header, value|
+          it "returns headers #{header} wih value: #{value}" do
+            expect(last_response.headers[header.to_s]).to eq(eval(value))
           end
         end
-
       end
-      alias_method :it_returns_more_attribute_values, :it_returns_attribute_values
-
 
-      def it_returns_no_attributes(resource:, attributes: [])
-        it "expects returned resource (#{resource}) to NOT have the following attributes" do
-          api_resource = objectize_resource(
-            last_response.body, root: resource, existing: false
-          )
+      def it_returns_attribute_values(options = {})
+        it "expects returned resource (#{options[:resource]}) to have model attribute values" do
+          resource = dispatcher.adapter.resource(options.merge(existing: true), last_response, self)
 
-          attributes.each do |attribute|
+          #support proc on attrs
+          options[:attrs].each do |attribute|
             begin
-              expect(api_resource.send(attribute)).to eql(:attribute_not_found)
+              resource.compare_attribute(attribute)
             rescue RSpec::Expectations::ExpectationNotMetError => e
               e.message << "failed at model attribute: #{attribute}"
               raise e
@@ -64,61 +31,45 @@ module Rspec
           end
         end
       end
+      alias_method :it_returns_more_attribute_values, :it_returns_attribute_values
 
-      def it_includes_in_headers(headers = {})
-        headers.each do |header, value|
-          it "returns headers #{header} wih value: #{value}" do
-            expect(last_response.headers[header.to_s]).to eq(eval(value))
-          end
-        end
-      end
+      def it_returns_no_attributes(options = {})
+        it "expects returned resource (#{options[:root]}) to NOT have the following attributes" do
+          resource = dispatcher.adapter.resource(options.merge(existing: false), last_response, self)
 
-      def it_returns_collection_size(resource:, size:)
-        it "returns the correct number of resources in the #{resource} collection" do
-          resources = objectize_resources(last_response.body, root: resource)
-          expect(resources.length).to eql(size)
+          options[:attrs].each do |attribute|
+            begin
+              resource.has_no_attribute(attribute)
+            rescue RSpec::Expectations::ExpectationNotMetError => e
+              e.message << "failed at model attribute: #{attribute}"
+              raise e
+            end
+          end
         end
       end
 
-      def it_returns_collection_embedded_size(resource:, embeds:, size:)
-        it "returns the correct number of embedded resource #{embeds} in the #{resource} collection" do
-          resources = objectize_resources(last_response.body, root: resource)
-          expect(resources.sample[embeds].length).to eql(size)
-        end
-      end
+      def it_returns_collection_size(options = {})
+        it "returns the correct number of resources in the #{options[:resource]} collection" do
+          collection = dispatcher.adapter.collection(options.merge(existing: true), last_response, self)
 
-      def it_returns_embedded_size(resource:, embeds:, size:)
-        it "returns the correct number of embedded resource #{embeds} in the #{resource} resource" do
-          resource = objectize_resource(last_response.body, root: resource)
-          expect(resource.send(embeds).length).to eql(size)
+          collection.has_size(options[:size])
         end
       end
 
-      def it_returns_collection_attributes(resource:, attributes: [], subset: true)
-        it "returns the correct attributes (no value checking) for each resource in the #{resource} collection" do
-          resources = objectize_resources(last_response.body, root: resource.pluralize)
+      def it_returns_collection_attributes(options = {})
+        it "returns the correct attributes (no value checking) for resources in the #{options[:resource]} collection" do
+          sample_resource = dispatcher.adapter.collection(
+            options, last_response, self
+          ).sample(existing: true, resource: nil)
 
-          resource_attributes_set = SortedSet.new(
-            resources.sample.hash.keys.map(&:to_s)
-          )
-          checking_attributes_set = SortedSet.new(attributes.map(&:to_s).to_set)
-
-          if subset
+          #support proc on attrs
+          options[:attrs].each do |attribute|
             begin
-              expect(resource_attributes_set.superset?(checking_attributes_set)).to(
-                eq(true)
-              )
-            rescue RSpec::Expectations::ExpectationNotMetError => _
-              raise(
-                $!,
-                superset_mismatch_error(
-                  resource_attributes_set, checking_attributes_set
-                ),
-                $!.backtrace
-              )
+              sample_resource.has_attribute(attribute)
+            rescue RSpec::Expectations::ExpectationNotMetError => e
+              e.message << "failed at model attribute: #{attribute}"
+              raise e
             end
-          else
-            expect(resource_attributes_set).to eq(checking_attributes_set)
           end
         end
       end
@@ -127,52 +78,35 @@ module Rspec
         :it_returns_collection_attributes
       )
 
-      def it_returns_collection_embedded_resource_attributes(
-        resource:, embeds:, attributes: [], subset: true
-      )
-        it "returns the correct attributes (no value checking) of #{embeds} resource inside #{resource} collection" do
-          resource = objectize_resources(last_response.body, root: resource)
-          embedded_resource = object_hash(resource.sample.send(embeds.to_sym))
-
-          embedded_resource_attributes_set = SortedSet.new(
-            embedded_resource.hash.keys.map(&:to_s)
-          )
-          checking_attributes_set = SortedSet.new(attributes.map(&:to_s).to_set)
+      def it_returns_no_collection_attributes(options = {})
+        it "expects returned collection (#{options[:resource]}) to NOT have the following attributes" do
+          sample_resource = dispatcher.adapter.collection(
+            options, last_response, self
+          ).sample(existing: false, resource: nil)
 
-          if subset
+          #support proc on attrs
+          options[:attrs].each do |attribute|
             begin
-              expect(
-                embedded_resource_attributes_set.superset?(
-                  checking_attributes_set
-                )
-              ).to(
-                eq(true)
-              )
-            rescue RSpec::Expectations::ExpectationNotMetError => _
-              raise(
-                $!,
-                superset_mismatch_error(
-                  embedded_resource_attributes_set, checking_attributes_set
-                ),
-                $!.backtrace
-              )
+              sample_resource.has_no_attribute(attribute)
+            rescue RSpec::Expectations::ExpectationNotMetError => e
+              e.message << "failed at model attribute: #{attribute}"
+              raise e
             end
-          else
-            expect(resource_attributes_set).to eq(checking_attributes_set)
           end
         end
-
       end
 
-      def it_returns_no_collection_attributes(resource:, attributes: [])
-        it "expects returned collection (#{resource}) to NOT have the following attributes" do
-          resources = objectize_resources(
-            last_response.body, root: resource.pluralize, existing: false
-          )
+      #finds_by id
+      def it_returns_collection_attribute_values(options = {})
+        it "expects returned collection (#{options[:resource]}) to have model attribute values" do
+          resource = dispatcher.adapter.collection(
+            options, last_response, self
+          ).find_by(:id, existing: true, resource: nil)
 
-          attributes.each do |attribute|
+          #support proc on attrs
+          options[:attrs].each do |attribute|
             begin
-              expect(resources.sample.send(attribute)).to eql(:attribute_not_found)
+              resource.compare_attribute(attribute)
             rescue RSpec::Expectations::ExpectationNotMetError => e
               e.message << "failed at model attribute: #{attribute}"
               raise e
@@ -181,29 +115,36 @@ module Rspec
         end
       end
 
-      def it_returns_no_collection_embedded_resource_attributes(
-        resource:, embeds:, attributes: []
-      )
-        it "expects the embedded resource #{embeds} inside the returned collection (#{resource}) to NOT have the following attributes" do
-          resources = objectize_resources(
-            last_response.body, root: resource.pluralize
-          )
+=begin
+      #not tested
+      def it_returns_embedded_collection_size(options = {})
+        it "returns the correct number of embedded resource #{embeds} in the #{resource} resource" do
+          collection = dispatcher.adapter.resource(
+            options.merge(existing: true), last_response, self
+          ).embedded_collection
 
-          embedded_resource = object_hash(
-            resources.sample.send(embeds.to_sym), existing: false
-          )
+          collection.has_size(options[:size])
+        end
+      end
+
+      def it_returns_collection_embedded_collection_size(options = {})
+        it "returns the correct number of embedded resource #{embeds} in the #{resource} collection" do
 
-          attributes.each do |attribute|
-            begin
-              expect(embedded_resource.send(attribute)).to eql(:attribute_not_found)
-            rescue RSpec::Expectations::ExpectationNotMetError => e
-              e.message << "failed at model attribute: #{attribute}"
-              raise e
-            end
-          end
         end
       end
 
+      def it_returns_collection_embedded_resource_attributes(options = {})
+        it "returns the correct attributes (no value checking) of #{embeds} resource inside #{resource} collection" do
+
+        end
+      end
+
+      def it_returns_no_collection_embedded_resource_attributes(options = {})
+        it "expects the embedded resource #{embeds} inside the returned collection (#{resource}) to NOT have the following attributes" do
+
+        end
+      end
+=end
     end
   end
 end

data/lib/rspec/api_helpers/example_methods.rb

@@ -3,67 +3,8 @@ require "rspec/api_helpers/version"
 module Rspec
   module ApiHelpers
     module ExampleMethods
-      def objectize_resources(json, root:, existing: true)
-        array = []
-        array_hash = HashWithIndifferentAccess.new(JSON.parse(json))
-
-        if root
-          array_hash = array_hash[root]
-        end
-
-        array_hash.each do |resource|
-          array << object_hash(resource, existing: existing)
-        end
-
-        return array
-      end
-
-      def objectize_resource(json, root:, existing: true)
-        hash = HashWithIndifferentAccess.new(JSON.parse(json))
-        if root
-          obj = object_hash(hash[root], existing: existing)
-        else
-          obj = object_hash(hash, existing: existing)
-        end
-
-        return obj
-      end
-
-      def object_hash(hash, existing: true)
-        ObjectHash.new(hash, existing: existing)
-      end
-
-      class ObjectHash
-        #existing denotes whether we search for attributes that exist on the
-        #resource or attributes that shouldn't exist
-        attr_accessor :hash, :existing
-        def initialize(hash, existing: true)
-          @hash = HashWithIndifferentAccess.new(hash)
-          @existing = existing
-        end
-        def method_missing(name)
-          if existing
-            if hash.key?(name)
-              return hash[name]
-            else
-              return raise KeyError.new("Attribute not found in resource: #{name}")
-            end
-          else
-            if hash.key?(name)
-              return raise(
-                KeyError.new(
-                  "Attribute found in resource when it shouldn't: #{name}"
-                )
-              )
-            else
-              return :attribute_not_found
-            end
-          end
-        end
-      end
-
-      def superset_mismatch_error(superset, subset)
-        "Expected \n #{subset.to_a.to_s} \n to be included in \n #{superset.to_a.to_s}"
+      def dispatcher
+        @dispatcher ||= Rspec::ApiHelpers::Dispatcher.new
       end
     end
   end

data/lib/rspec/api_helpers/version.rb

@@ -1,5 +1,5 @@
 module Rspec
   module Api
-    VERSION = "0.2.1"
+    VERSION = "1.0.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-api_helpers
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Filippos Vasilakis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2016-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,12 @@ files:
 - README.md
 - Rakefile
 - lib/rspec/api_helpers.rb
+- lib/rspec/api_helpers/adapter/active_model/adapter.rb
+- lib/rspec/api_helpers/adapter/active_model/collection.rb
+- lib/rspec/api_helpers/adapter/active_model/common_helpers.rb
+- lib/rspec/api_helpers/adapter/active_model/resource.rb
+- lib/rspec/api_helpers/adapter/jsonapi/adapter.rb
+- lib/rspec/api_helpers/dispatcher.rb
 - lib/rspec/api_helpers/example_group_methods.rb
 - lib/rspec/api_helpers/example_methods.rb
 - lib/rspec/api_helpers/version.rb
@@ -77,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Rspec matchers for APIs