rspec-api_helpers 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1267d02472c6b6dc9488167e1b26a94338cf8ac1
-  data.tar.gz: b70848a92746fa4642d8a5723e802d134046ee53
+  metadata.gz: e39766df47a5e882fe90dabfe2fc4454891af1d6
+  data.tar.gz: 40e50c76772eb224404b81fb6106468bd610823c
 SHA512:
-  metadata.gz: 80a8a72d5999a2f57de18831edbfba0349bb231a70aed3766529d96cdc3cb61b4b4cad47f1ba05e21d2917265fdb2f9a3a882bbcd010761a20221ca249f3f54d
-  data.tar.gz: fbceba80d2355469c7be0560360b524519edca15f03d1a8ca7e8d8e0e3c3f399423ad3d3b7acd7f33d63aff19d14062e9b1ac108abe17d00174ef368e0a3865f
+  metadata.gz: 5a2376e96df8cd62d06b00ec44de1a70dc71139a9839c4f12b4488519aa572d6037e863b4bee42ad2ca5d06fa1c4350d6f88bf7be3ed83581fbf51b9ca2092b9
+  data.tar.gz: bda8bd3912b2f9fdebfb5bdebe38a04538eeb0dde5e3c1edd4d0b82689fa3e1566a4f2c5dd41de50cb2906104da42b7760355bc0b55a4dc999e9b34e0b992793

data/lib/rspec/api_helpers/example_group_methods.rb

@@ -2,29 +2,39 @@ module Rspec
   module ApiHelpers
     module ExampleGroupMethods
       def it_returns_status(status)
-        it 'returns the correct status' do
+        it "returns the correct HTTP status (status: #{status})" do
           expect(last_response.status).to eql(status)
         end
       end
 
-      def it_returns_attributes(resource:, model:, only: [], modifier: nil)
-        it "expects returned resource to have the following model's attributes" do
-          @api_resource = objectize_resource(last_response.body, root: resource)
+      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)
 
-          @model = eval(model)
-          if @model.is_a? Hash
-            @model = object_hash(@model)
+          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
-                  expect(@api_resource.send(attribute)).to(
-                    eql(@model.send(attribute).send(modifier.to_sym))
+                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))
+                  expect(api_resource.send(attribute)).to(
+                    eql(model.send(attribute))
+                  )
                 end
               rescue RSpec::Expectations::ExpectationNotMetError => e
                 e.message << "failed at model attribute: #{attribute}"
@@ -35,24 +45,151 @@ module Rspec
         end
 
       end
-      alias_method :it_returns_db_model, :it_returns_attributes
-      alias_method :it_returns_more_attributes, :it_returns_attributes
+      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
+          )
+
+          attributes.each do |attribute|
+            begin
+              expect(api_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_includes_in_headers(headers = {})
-        it 'returns the correct headers' do
-          headers.each do |header, value|
+        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_resources(root:, number:)
-        it 'returns the correct number of data in the body' do
-          users = objectize_resources(last_response.body, root: root)
-          expect(users.length).to eql(number)
+      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)
         end
       end
-      alias_method :it_returns_the_resources, :it_returns_resources
+
+      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)
+
+          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
+            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
+              )
+            end
+          else
+            expect(resource_attributes_set).to eq(checking_attributes_set)
+          end
+        end
+      end
+      alias_method(
+        :it_returns_more_collection_attributes,
+        :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)
+
+          if subset
+            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
+              )
+            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
+          )
+
+          attributes.each do |attribute|
+            begin
+              expect(resources.sample.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_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
+          )
+
+          embedded_resource = object_hash(
+            resources.sample.send(embeds.to_sym), existing: false
+          )
+
+          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
+
     end
   end
 end

data/lib/rspec/api_helpers/example_methods.rb

@@ -3,46 +3,68 @@ require "rspec/api_helpers/version"
 module Rspec
   module ApiHelpers
     module ExampleMethods
-      def objectize_resources(json, root:)
+      def objectize_resources(json, root:, existing: true)
         array = []
-        array_hash = HashWithIndifferentAccess.new(JSON.load(json))
+        array_hash = HashWithIndifferentAccess.new(JSON.parse(json))
 
         if root
           array_hash = array_hash[root]
         end
 
         array_hash.each do |resource|
-          array << object_hash(resource)
+          array << object_hash(resource, existing: existing)
         end
 
         return array
       end
 
-      def objectize_resource(json, root:)
-        hash = HashWithIndifferentAccess.new(JSON.load(json))
+      def objectize_resource(json, root:, existing: true)
+        hash = HashWithIndifferentAccess.new(JSON.parse(json))
         if root
-          obj = object_hash(hash[root])
+          obj = object_hash(hash[root], existing: existing)
         else
-          obj = object_hash(hash)
+          obj = object_hash(hash, existing: existing)
         end
 
         return obj
       end
 
-      def object_hash(hash)
-        ObjectHash.new(hash)
+      def object_hash(hash, existing: true)
+        ObjectHash.new(hash, existing: existing)
       end
 
       class ObjectHash
-        attr_accessor :hash
-        def initialize(hash)
+        #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)
-          return hash[name] if hash.key? name
-          raise KeyError.new("Attribute not found in resource: #{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
     end
   end
 end

data/lib/rspec/api_helpers/version.rb

@@ -1,5 +1,5 @@
 module Rspec
   module Api
-    VERSION = "0.0.2"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-api_helpers
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Filippos Vasilakis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler