rspec-api 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f66889873ee973973a2f419e950bd9f405abe7e2
-  data.tar.gz: bbd9a7c7f60d30eaad0e46a28de310e538933bc3
+  metadata.gz: 9ca5599e96ba26d321698c09c88a338919c4bf8a
+  data.tar.gz: ae0a49475f6343996a3eb2313ecba068e20db34b
 SHA512:
-  metadata.gz: 0bfaa8bfff6796c6620802a92505c7c4d89c29bfac3283123ab8d9aec942bb8805c02030434646898f119a36f817ca838b4182fcf776cfe02484af0e624a138e
-  data.tar.gz: 6eb04e4cd39cbf6275a1a8ce4e850996e3d27417bdd004947830ca1a11d484633fcb742636ea9c25f3d7f571b634b72efabc4f69a4dc0b4029c8dfa9a3e4ebb1
+  metadata.gz: c26cdc3ffe743a93ee67be9567a2fcbf70810f54381c866b971626cd4a5961828fcfb56e0dceddeeea3e5a0b5ab08119a8aefb787262f7df3c9bc0aa8aacf4f1
+  data.tar.gz: 26b169c8bbaa0d2e9893b764bcfadcf9a187942a312dc6ca2fb17cb41391b4d153c1f65e94d74063a77a32b8249fe476619874b4f8b665c939a45337af8c4f95

data/lib/rspec-api.rb

@@ -0,0 +1 @@
+require 'rspec-api/dsl'

data/lib/rspec-api/dsl.rb

@@ -1,24 +1,45 @@
-require 'rspec-api/dsl/resource'
-require 'rspec-api/dsl/route'
-require 'rspec-api/dsl/request'
+require 'rspec-api/dsl/accepts'
+require 'rspec-api/dsl/actions'
+require 'rspec-api/dsl/attributes'
 
-module DSL
+module RSpecApi
+  module DSL
+    include Accepts
+    include Actions
+    include Attributes
+    include Fixtures
+  end
 end
 
-# Just like RSpec Core’s `describe` method, `resource` generates a subclass of
-# {ExampleGroup} and is available at the top-level namespace.
-# The difference is that examples declared inside a `resource` block have access
-# to RSpec API own methods, defined in DSL::Resource, such as `has_attribute`,
-# `accepts_filter`, `get`, `post`, and so on.
-def resource(name, args = {}, &block)
-  args.merge! rspec_api_dsl: :resource, rspec_api: {resource_name: name}
-  describe name, args, &block
-end
+# RSpecApi provides methods to test RESTful APIs.
+#
+# To have these methods available in your RSpec ExampleGroups you have to
+# tag the `describe` block with the `:rspec_api` metadata.
+#
+#  describe "Artists", rspec_api: true do
+#     ... # here you can use `get`, `delete`, etc.
+#  end
+RSpec.configuration.extend RSpecApi::DSL, rspec_api: true
 
-RSpec.configuration.include DSL::Resource, rspec_api_dsl: :resource
-RSpec.configuration.include DSL::Route, rspec_api_dsl: :route
-RSpec.configuration.include DSL::Request, rspec_api_dsl: :request
-
-if RSpec::Core::Version::STRING >= '2.14'
-  RSpec.configuration.backtrace_exclusion_patterns << %r{lib/rspec-api/dsl\.rb}
+# Alternatively, you replace `describe` with `resource`, for the same result:
+#
+#
+#  resource :artist do
+#     ... # same as before, here you can use `get`, `delete`, etc.
+#  end
+#
+#
+# `resource` is indeed the only top-level namespace RSpecApi method.
+def resource(name, args = {}, &block)
+  args.merge! rspec_api: true
+  resources = (@resources ||= [])
+  resource = describe name.to_s.pluralize.humanize, args do
+    @resource = name
+    @resources = resources
+    @expectations = []
+    @expectations << {query_params: {}, status_expect: {status: 200}, body_expect: {attributes: {name: {type: :string}, website: {type: [:null, string: :url]}}}}
+    @attributes = {}
+    instance_exec &block
+  end
+  @resources << resource
 end

data/lib/rspec-api/dsl/accepts.rb

@@ -0,0 +1,46 @@
+module RSpecApi
+  module DSL
+    module Accepts
+
+      def accepts_page(page_parameter)
+        any_page = 2
+        @expectations << {
+          query_params: {}.tap{|qp| qp[page_parameter] = any_page},
+          status_expect: {status: 200},
+          headers_expect: {has_prev_page: true}
+        }
+      end
+
+      def accepts_sort(sort_parameter, options={})
+        @expectations << {
+          query_params: {sort: sort_parameter}.merge(options.fetch(:sort_if, {})),
+          before: create_fixture,
+          after: destroy_fixture,
+          status_expect: {status: 200},
+          body_expect: {sort: options.slice(:by, :verse)}
+        }
+      end
+
+      def accepts_callback(callback_parameter)
+        any_callback = 'a_callback'
+        @expectations << {
+          query_params: {}.tap{|qp| qp[callback_parameter] = any_callback},
+          status_expect: {status: 200},
+          body_expect: {callback: any_callback}
+        }
+      end
+
+      def accepts_filter(filter_parameter, options={})
+        value = existing(options[:by])
+        @expectations << {
+          query_params: {}.tap{|qp| qp[filter_parameter] = value},
+          before: create_fixture,
+          after: destroy_fixture,
+          status_expect: {status: 200},
+          body_expect: {filter: options.slice(:by, :comparing_with).merge(value: value)}
+        }
+      end
+    end
+  end
+end
+

data/lib/rspec-api/dsl/actions.rb

@@ -0,0 +1,36 @@
+require 'rspec-api/dsl/requests'
+
+module RSpecApi
+  module DSL
+    module Actions
+      include RSpecApi::DSL::Fixtures
+      include RSpecApi::DSL::Requests
+
+      def self.define_action(action)
+        define_method action do |route, options = {}, &block|
+          expectations = @expectations
+          attributes = @attributes
+          authorization = @authorization
+          resource = @resource
+          collection = options[:collection]
+          describe "#{action.upcase} #{route}" do
+            @action = action
+            @route = route
+            @expectations = expectations
+            @attributes = attributes
+            @authorization = authorization
+            @collection = collection
+            @resource = resource
+            instance_eval &block
+          end
+        end
+      end
+
+      define_action :get
+      define_action :put
+      define_action :patch
+      define_action :post
+      define_action :delete
+    end
+  end
+end

data/lib/rspec-api/dsl/attributes.rb

@@ -0,0 +1,13 @@
+module RSpecApi
+  module DSL
+    module Attributes
+      def has_attribute(name, options = {}, &block)
+        @attributes[name] = options
+      end
+
+      def attributes_of(resource)
+        @resources.find{|r| r.description == resource.to_s.pluralize.humanize}.instance_variable_get '@attributes'
+      end
+    end
+  end
+end

data/lib/rspec-api/dsl/requests.rb

@@ -0,0 +1,78 @@
+require 'rspec-api/dsl/responses'
+
+module RSpecApi
+  module DSL
+    module Requests
+      def my_collection_request(query_params = {}, &block)
+        @expectations.each do |options|
+          single_request(options.deep_merge(body_expect: {collection: true}, query_params: query_params), &block)
+        end
+      end
+
+      def respond_with(*args) # NOT THE TRUE ONE
+        request_with do
+          respond_with(*args)
+        end
+      end
+
+      def request_with(query_params = {}, &block)
+        if @collection
+          my_collection_request(query_params, &block)
+        else
+          single_request(query_params: query_params, &block)
+        end
+      end
+
+      def single_request(options = {}, &block)
+        query_params = options.fetch(:query_params, {})
+        status_expect = options.fetch(:status_expect, {status: 200})
+        headers_expect = options.fetch(:headers_expect, {type: :json})
+        body_expect = options.fetch(:body_expect, {collection: false}) # Or maybe nothing
+        body_expect = body_expect.merge(attributes: @attributes) if @attributes
+        before_fun = options.fetch(:before, -> {})
+        after_fun = options.fetch(:after, -> {})
+        query = {authorization: @authorization, route_params: {}, action: @action, route: @route, query_params: query_params, status_expect: status_expect, headers_expect: headers_expect, body_expect: body_expect, before: before_fun, after: after_fun}
+
+        query_params.each do |k, v|
+          if v.is_a?(Hash) && v[:proc] && v[:value] # so we avoid getting the hash of the callback called :proc
+            query[:query_params][k] = v[:value]
+            if v[:proc] == :existing
+              query = query.merge before: create_fixture, after: destroy_fixture
+            end
+          end
+        end
+
+        my_real_request(query, &block)
+      end
+
+      def my_real_request(query = {}, &block)
+        query[:before].call
+
+        query.fetch(:query_params, {}).each do |k, v|
+          query[:query_params][k] = v.is_a?(Proc) ? v.call : v
+          if query[:route].match "/:#{k}"
+            query[:route] = query[:route].gsub "/:#{k}", "/#{query[:query_params][k]}"
+            query[:route_params][k] = query[:query_params].delete k
+          end
+        end
+
+        describe "with #{query[:route].is_a?(Proc) ? query[:route].call : query[:route]}#{" and #{query[:query_params]}" if query[:query_params].any?}" do
+          extend RSpecApi::DSL::Responses
+          extend RSpecApi::DSL::HttpClient
+          send_request query[:action], (query[:route].is_a?(Proc) ? query[:route].call : query[:route]), query[:query_params], query[:authorization]
+          @response = last_response
+          @status_expect = query.fetch :status_expect, {}
+          @headers_expect = query.fetch :headers_expect, {}
+          @body_expect = query.fetch :body_expect, {}
+          @route_params = query.fetch :route_params, {}
+          if @body_expect.fetch(:filter, {})[:value].is_a?(Hash) && @body_expect.fetch(:filter, {})[:value][:proc]
+            @body_expect[:filter][:value] = @body_expect[:filter][:value][:value].call
+          end
+          instance_exec &block
+        end
+
+        query[:after].call
+      end
+    end
+  end
+end

data/lib/rspec-api/dsl/responses.rb

@@ -0,0 +1,37 @@
+require 'rspec-api/expectations'
+
+module RSpecApi
+  module DSL
+    module Responses
+      include RSpecApi::Expectations::Resourceful
+
+      def respond_with(*args, &block)
+        if args.first.is_a?(Hash)
+          more_status_expect = args.first
+          more_headers_expect = {}
+          more_body_expect = {}
+        elsif args.first.is_a?(Array)
+          more_status_expect, more_headers_expect, more_body_expect = args
+        else
+          more_status_expect = {status: args.first}
+          more_headers_expect = {}
+          more_body_expect = {}
+        end
+
+        all_expectations = @status_expect.merge(more_status_expect).merge(
+        @headers_expect).merge(more_headers_expect).merge(@body_expect).
+        merge(more_body_expect)
+
+        expect_resourceful(@response, all_expectations)
+        expect_custom(@response, @route_params, &block) if block_given?
+      end
+
+      def expect_custom(response, route_params, &block)
+        context 'matches custom expectations' do
+          # THE ONLY MISSING THING:
+          it { instance_exec response, route_params, &block }
+        end
+      end
+    end
+  end
+end

data/lib/rspec-api/fixtures/empty.rb

@@ -0,0 +1,35 @@
+module RSpecApi
+  module DSL
+    module Fixtures # rename to Fixtures
+      def existing(field)
+        # To be overriden
+      end
+
+      def unknown(field)
+        # To be overriden
+      end
+
+      def apply(method_name, options = {})
+        options[:to].merge(apply: method_name, value: -> { options[:to][:value].call.send method_name })
+      end
+
+      def valid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def invalid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def create_fixture
+        # To be overriden
+      end
+
+      def destroy_fixture
+        # To be overriden
+      end
+    end
+  end
+end

data/lib/rspec-api/fixtures/local.rb

@@ -0,0 +1,50 @@
+module RSpecApi
+  module DSL
+    module Fixtures # rename to Fixtures
+      def existing(field)
+        {field: field, proc: :existing, value: existing_value_for(field)}
+      end
+
+      def unknown(field)
+        {field: field, proc: :unknown, value: missing_value_for(field)}
+      end
+
+      def apply(method_name, options = {})
+        options[:to].merge(apply: method_name, value: -> { options[:to][:value].call.send method_name })
+      end
+
+      def valid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def invalid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def create_fixture
+        # TODO: Random values from attributes
+        -> {
+          model = @resource.to_s.classify.constantize
+          case @resource
+          when :artist then model.create! name: 'Madonna', website: 'http://www.example.com'
+          when :concert then model.create! where: 'Coachella', year: 2010
+          end
+        }
+      end
+
+      def destroy_fixture
+        -> {@resource.to_s.classify.constantize.destroy_all}
+      end
+
+      def existing_value_for(field)
+        -> {@resource.to_s.classify.constantize.pluck(field).first}
+      end
+      
+      def missing_value_for(field)
+        -> {-1}
+      end
+    end
+  end
+end

data/lib/rspec-api/fixtures/remote.rb

@@ -0,0 +1,82 @@
+module RSpecApi
+  module DSL
+    module Fixtures # rename to Fixtures
+      def existing(field)
+        {field: field, proc: :existing, value: existing_value_for(field)}
+      end
+
+      def unknown(field)
+        {field: field, proc: :unknown, value: missing_value_for(field)}
+      end
+
+      def apply(method_name, options = {})
+        options[:to].merge(apply: method_name, value: -> { options[:to][:value].call.send method_name })
+      end
+
+      def valid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def invalid(options = {})
+        # TODO: Here change the description
+        options
+      end
+
+      def create_fixture
+        # TODO: Nothing for now
+        -> { }
+      end
+
+      def destroy_fixture
+        # TODO: Nothing for now
+        -> { }
+      end
+
+      def existing_value_for(field)
+        value = case field
+        when :org then 'rspec-api'
+        when :user, :owner, :assignee then 'rspecapi'
+        when :repo then 'guinea-pig' # has heads, tails, pull, notes
+        when :gist_id then '7175672'
+        when :gist_comment_id then '937901'
+
+        when :blob_sha then 'f32932f7c927d86f57f56d703ac2ed100ceb0e47'
+        when :commit_sha then 'c98a37ea3b2759d0c43fb8abfa9abd3146938790'
+        when :tree_sha then 'ebca91692290192f50acc307af9fe26b2eab4274'
+        when :ref then 'heads/master'
+        when :starred_repo then 'rspec-expectations' # make it different from :repo
+        when :unstarred_repo then 'rspec-core'  # make it different from :repo
+        when :starred_gist_id then 'e202e2fb143c54e5139a'
+        when :unstarred_gist_id then '8f2ef7e69ab79084d833'
+        when :someone_elses_gist_id then '4685e0bebbf05370abd6'
+        when :thread_id then '17915960'
+        when :id then '921225'
+        # NOTE: The following are confusing: they are used for filters, not value
+        # For instance, it's not that we must have an object with the following
+        # updated_at, we just use it for the since filter
+        when :updated_at then '2013-10-31T09:53:00Z' # TODO use helpers
+        # NOTE: Here's the confusion: :unread is used for the :all filter, but
+        # it has the reverse meaning: ?all=false will only show unread='true'
+        when :unread then 'false' # TODO use helpers
+        # NOTE: Here's more confusion: :reason is a string, but this is used for
+        # the boolean parameter participating:
+        # ?participating=true (default), only show reason = 'mention' or 'author'
+        # ?participating=false, show all reasons
+        when :reason then 'true' # TODO use helpers
+        end
+        -> { value }
+      end
+
+      def missing_value_for(field)
+        value = case field
+        when :user, :assignee then 'not-a-valid-user'
+        when :gist_id then 'not-a-valid-gist-id'
+        when :id then 'not-a-valid-id'
+        when :repo then 'not-a-valid-repo'
+        end
+        -> { value }
+      end
+    end
+  end
+end

data/lib/rspec-api/http_clients/empty.rb

@@ -0,0 +1,14 @@
+module RSpecApi
+  module DSL
+    module HttpClient
+      def send_request(verb, route, body, authorization)
+        # To be overriden
+      end
+
+      def last_response
+        # To be overriden. status MUST be a number, headers MUST be a hash
+        OpenStruct.new status: nil, headers: {} # body: nil,
+      end
+    end
+  end
+end

data/lib/rspec-api/http_clients/local.rb

@@ -0,0 +1,28 @@
+require File.expand_path("../../../../spec/dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+require 'rack/test'
+
+def app
+  Rails.application
+end
+
+module RSpecApi
+  module DSL
+    module HttpClient
+      include Rack::Test::Methods
+
+      def ciao
+
+      end
+
+      def send_request(verb, route, body, authorization)
+        header 'Accept', 'application/json'
+        send verb, route, body
+      end
+
+      def response
+        last_response
+      end
+    end
+  end
+end

data/lib/rspec-api/{http/remote/route.rb → http_clients/remote.rb}

@@ -1,9 +1,18 @@
-module Http
-  module Remote
-    module Route
-      extend ActiveSupport::Concern
+require 'faraday'
+require 'faraday_middleware' # TODO: use autoload, we only need EncodeJson
+require 'faraday-http-cache'
+require 'logger'
 
-      def send_request(verb, route, body)
+module Authorize
+  def authorize_with(options = {})
+    @authorization = options
+  end
+end
+
+module RSpecApi
+  module DSL
+    module HttpClient
+      def send_request(verb, route, body, authorization)
         logger = Logger.new 'log/faraday.log'
 
         conn = Faraday.new 'https://api.github.com/' do |c| # TODO: Pass host as a parameter
@@ -23,9 +32,8 @@ module Http
         end
       end
 
-      def authorization
-        # TODO: Any other way to access metadata in a before(:all) ?
-        self.class.metadata[:rspec_api][:authorization]
+      def last_response
+        @last_response
       end
     end
   end

data/lib/rspec-api/version.rb

@@ -1,3 +1,3 @@
 module RspecApi
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-api
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - claudiob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-03 00:00:00.000000000 Z
+date: 2013-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -28,16 +28,30 @@ dependencies:
   name: rspec-api-matchers
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec-api-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -257,23 +271,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/rspec-api/dsl/request/body.rb
-- lib/rspec-api/dsl/request/headers.rb
-- lib/rspec-api/dsl/request/request.rb
-- lib/rspec-api/dsl/request/response.rb
-- lib/rspec-api/dsl/request/status.rb
-- lib/rspec-api/dsl/request.rb
-- lib/rspec-api/dsl/resource.rb
-- lib/rspec-api/dsl/route.rb
+- lib/rspec-api/dsl/accepts.rb
+- lib/rspec-api/dsl/actions.rb
+- lib/rspec-api/dsl/attributes.rb
+- lib/rspec-api/dsl/requests.rb
+- lib/rspec-api/dsl/responses.rb
 - lib/rspec-api/dsl.rb
-- lib/rspec-api/http/local/request.rb
-- lib/rspec-api/http/local/route.rb
-- lib/rspec-api/http/local.rb
-- lib/rspec-api/http/remote/request.rb
-- lib/rspec-api/http/remote/resource.rb
-- lib/rspec-api/http/remote/route.rb
-- lib/rspec-api/http/remote.rb
+- lib/rspec-api/fixtures/empty.rb
+- lib/rspec-api/fixtures/local.rb
+- lib/rspec-api/fixtures/remote.rb
+- lib/rspec-api/http_clients/empty.rb
+- lib/rspec-api/http_clients/local.rb
+- lib/rspec-api/http_clients/remote.rb
 - lib/rspec-api/version.rb
+- lib/rspec-api.rb
 - MIT-LICENSE
 - README.md
 homepage: https://github.com/rspec-api/rspec-api

data/lib/rspec-api/dsl/request.rb

@@ -1,5 +0,0 @@
-require 'rspec-api/dsl/request/request'
-require 'rspec-api/dsl/request/response'
-require 'rspec-api/dsl/request/status'
-require 'rspec-api/dsl/request/headers'
-require 'rspec-api/dsl/request/body'

data/lib/rspec-api/dsl/request/body.rb

@@ -1,85 +0,0 @@
-require 'active_support'
-require 'rspec-api/matchers'
-
-module DSL
-  module Request
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # Creates an example group for expectations on the response body of the
-      # last API request and runs it to verify that it matches best practices:
-      # * if response is succesful and has a body
-      #   -  the body should be a JSON-marshalled Array or Hash
-      #   -  if request has a callback parameter, the body should be JSONP
-      #   -  if request has a sort parameter, the body should be sorted
-      #   -  if request has a filter parameter, the body should be filtered
-      #   -  if custom expectations are passed, they should pass
-      #   -  if some attributes are expected, the body should include them
-      def should_respond_with_expected_body(options = {})
-        context 'responds with a body that' do
-          it { should_be_valid_json options[:type] }
-          it { should_be_wrapped_by options[:callbacks] }
-          it { should_be_sorted_by options[:sorts] }
-          it { should_be_filtered_by options[:filters] }
-          it { should_have_attributes options[:attributes] }
-        end
-      end
-    end
-
-    def should_be_valid_json(type)
-      expect(response).to be_valid_json_if response_is_successful?, type
-    end
-
-    # If the request had a 'callback' query parameter, then the body should be
-    # JSONP, otherwise it should not. For instance if the request was
-    # `GET /?method=alert` and the request `accepts_callback :method`, then
-    # the body must be a JSON wrapped in the alert(...) callback
-    # The +callback+ param says how the request might have been made, e.g.
-    # name: 'method', value: 'alert'... however to make sure that it was
-    # really made, we need to check that request_params['method'] is present
-    # and that is actually 'alert'
-    def should_be_wrapped_by(callback_params_sets)
-      callback_params = response_is_successful? && get_request_param_for_list(callback_params_sets)
-      value = callback_params[:value] if callback_params
-      expect(response).to be_a_jsonp_if callback_params, value
-    end
-
-    def should_be_sorted_by(sort_params_sets)
-      sort_params = response_is_successful? && get_request_param_for_list(sort_params_sets)
-      options = sort_params ? sort_params.slice(:by, :verse) : {}
-      expect(response).to be_sorted_if sort_params, options
-    end
-
-    def should_be_filtered_by(filter_params_sets)
-      # TODO: The following is just so the condition does not match if it's nil
-      #       but this should be fixed in get_request_param_for_list
-      if filter_params_sets
-        filter_params_sets = filter_params_sets.dup
-        filter_params_sets.each{|x| x[:value] = request_params.fetch(x[:name].to_s, :something_nil)}
-      end
-      filter_params = response_is_successful? && get_request_param_for_list(filter_params_sets)
-      value = filter_params[:value] if filter_params
-      options = filter_params ? filter_params.slice(:by, :comparing_with) : {}
-      expect(response).to be_filtered_if filter_params, value, options
-    end
-
-    def should_have_attributes(attributes)
-      expect(response).to have_attributes_if response_is_successful?, attributes
-    end
-
-    def get_request_param_for_list(params_sets)
-      (params_sets || []).find do |params|
-        conditions = []
-        conditions << (request_params[params[:name].to_s] == params[:value])
-        params.fetch(:extra_fields, {}).each do |name, value|
-          conditions << (request_params[name.to_s] == value)
-        end
-        conditions.all?
-      end
-    end
-
-    def response_is_successful?
-      response.status < 400 && !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(response.status)
-    end
-  end
-end

data/lib/rspec-api/dsl/request/headers.rb

@@ -1,40 +0,0 @@
-require 'active_support'
-require 'rack/utils'
-require 'rspec-api/matchers'
-
-module DSL
-  module Request
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # Creates an example group for expectations on the response headers of
-      # last API request and runs it to verify that it matches best practices:
-      # * if request has entity body, the Content-Type header should be JSON
-      # * if request has pages, the Link header should have a 'rel=prev' link
-      def should_respond_with_expected_headers(options = {})
-        context 'responds with headers that' do
-          it { should_include_content_type :json }
-          it { should_have_prev_page_link options[:page] }
-        end
-      end
-    end
-
-  private
-
-    def should_include_content_type(type)
-      expect(response).to include_content_type_if response_has_body?, type
-    end
-
-    def should_have_prev_page_link(page)
-      expect(response).to have_prev_page_link_if request_is_paginated?(page)
-    end
-
-    def response_has_body?
-      !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(response.status)
-    end
-
-    def request_is_paginated?(page_parameter)
-      request_params.key? page_parameter.to_s
-    end
-  end
-end

data/lib/rspec-api/dsl/request/request.rb

@@ -1,14 +0,0 @@
-require 'active_support'
-
-module DSL
-  module Request
-    extend ::ActiveSupport::Concern
-
-    module ClassMethods
-    end
-
-    def request_params
-      {} # To be overriden by more specific modules
-    end
-  end
-end

data/lib/rspec-api/dsl/request/response.rb

@@ -1,86 +0,0 @@
-require 'active_support'
-
-module DSL
-  module Request
-    extend ::ActiveSupport::Concern
-
-    module ClassMethods
-      # Runs a set of expectations on the result of the last API request.
-      # The most basic way to call `respond_with` is with a status code:
-      #
-      #     respond_with :ok
-      #
-      # This simple line will run a number of expectations, based on best
-      # practices that any RESTful API is expected to match:
-      # * the returned HTTP status will be matched against 200 OK
-      # * the response headers will be checked for Content-Type etc.
-      # * the respone body will be checked for attributes etc.
-      #
-      # Additionally, the user can specify custom expectations for the
-      # response by passing a block to the method:
-      #
-      #    respond_with :ok do |response|
-      #      expect(response).to be_successful?
-      #    end
-      #
-      # In this case, after all the *implicit* expectations are run, the
-      # JSON-parsed response body is passed to the block to make sure that
-      # (in the example above), the body is a hash with a 'color' key and
-      # the 'green' value
-      def respond_with(status_symbol, &block)
-        should_respond_with_status status_symbol
-        should_respond_with_expected_headers headers_options
-        should_respond_with_expected_body body_options
-        should_match_custom_response_expectations &block if block_given?
-      end
-
-    private
-
-      def headers_options
-        {page: rspec_api.fetch(:page, {})[:name].to_s}
-      end
-
-      def body_options
-        {
-          type: rspec_api[:array] ? Array : Hash,
-          callbacks: rspec_api.fetch(:callbacks, []),
-          sorts: rspec_api.fetch(:sorts, []),
-          filters: rspec_api.fetch(:filters, []),
-          attributes: rspec_api.fetch(:attributes, {})
-        }
-      end
-
-      def should_match_custom_response_expectations(&block)
-        it { instance_exec response, @url_params, &block }
-      end
-    end
-
-    def response
-      # To be overriden by more specific modules
-      OpenStruct.new # body: nil, status: nil, headers: {}
-    end
-
-    def response_body
-      JSON response_body_without_callbacks
-    rescue JSON::ParserError, JSON::GeneratorError
-      nil
-    end
-
-    def response_headers
-      response.headers || {}
-    end
-
-    def response_status
-      response.status
-    end
-
-  private
-
-    def response_body_without_callbacks
-      body = response.body
-      # TODO: extract the 'a_callback' constant
-      callback_pattern = %r[a_callback\((.*?)\)]
-      body =~ callback_pattern ? body.match(callback_pattern)[1] : body
-    end
-  end
-end

data/lib/rspec-api/dsl/request/status.rb

@@ -1,18 +0,0 @@
-require 'active_support'
-require 'rspec-api/matchers'
-
-module DSL
-  module Request
-    extend ::ActiveSupport::Concern
-
-    module ClassMethods
-      # Creates an example group for expectations on the HTTP status code of the
-      # last API request and runs it to verify that it matches +status+.
-      def should_respond_with_status(status)
-        context 'responds with a status code that' do
-          it { expect(response).to have_status status }
-        end
-      end
-    end
-  end
-end

data/lib/rspec-api/dsl/resource.rb

@@ -1,68 +0,0 @@
-require 'active_support'
-module DSL
-  module Resource
-    extend ::ActiveSupport::Concern
-
-    module ClassMethods
-      def rspec_api
-        metadata[:rspec_api]
-      end
-
-      def self.define_action(verb)
-        define_method verb do |route, args = {}, &block|
-          rspec_api.merge! array: args.delete(:array), verb: verb, route: route
-          args.merge! rspec_api_dsl: :route
-          describe("#{verb.upcase} #{route}", args, &block)
-        end
-      end
-
-      define_action :get
-      define_action :put
-      define_action :patch
-      define_action :post
-      define_action :delete
-
-
-      def has_attribute(name, options = {}, &block)
-        if block_given?
-          # options[:type] can be symbol, hash or array
-          # but if you have a block we must make it a hash
-          options[:type] = Hash[*Array.wrap(options[:type]).map{|x| x.is_a?(Hash) ? [x.keys.first, x.values.first] : [x, {}]}.flatten] unless options[:type].is_a? Hash
-          # we only set the block as the new format of Object and Array
-          nest_attributes(options[:type], &Proc.new)
-        end
-        if @attribute_ancestors.present?
-          hash = @attribute_ancestors.last
-          hash.slice(:object, :array).each do |type, _|
-            (hash[type] ||= {})[name] = options
-          end
-        else
-          hash = (rspec_api[:attributes] ||= {})
-          hash[name] = options
-        end
-      end
-
-      def nest_attributes(hash, &block)
-        (@attribute_ancestors ||= []).push hash
-        yield
-        @attribute_ancestors.pop
-      end
-
-      def accepts_page(page_parameter)
-        rspec_api[:page] = {name: page_parameter, value: 2}
-      end
-
-      def accepts_sort(sort_parameter, options={})
-        (rspec_api[:sorts] ||= []) << options.merge(name: 'sort', value: sort_parameter)
-      end
-
-      def accepts_filter(filter_parameter, options={})
-        (rspec_api[:filters] ||= []) << options.merge(name: filter_parameter)
-      end
-
-      def accepts_callback(callback_parameter)
-        (rspec_api[:callbacks] ||= []) << {name: callback_parameter.to_s, value: 'a_callback'}
-      end
-    end
-  end
-end

data/lib/rspec-api/dsl/route.rb

@@ -1,135 +0,0 @@
-require 'active_support/core_ext/object' # present?
-
-
-module DSL
-  module Route
-    extend ActiveSupport::Concern
-
-    def send_request(verb, route, body)
-      # To be overriden by more specific modules
-    end
-
-    module ClassMethods
-      def request(*args, &block)
-        text, values = parse_request_arguments args
-        sets_of_parameters.each do |params|
-          request_with_params text, values.merge(params), &block
-        end
-      end
-
-      def setup_fixtures
-        # To be overriden by more specific modules
-      end
-
-      def existing(field)
-        # To be overriden by more specific modules
-      end
-
-    private
-
-      def request_with_params(text, values = {}, &block)
-        context request_description(text, values), rspec_api_dsl: :request do
-          # NOTE: Having setup_fixtures inside the context sets up different
-          # fixtures for each `request` inside the same `get`. This might be
-          # a little slower on the DB, but ensures that two `request`s do not
-          # conflict. For instance, if you have two `request` inside a `delete`
-          # and the first deletes an instance, the second `request` is no
-          # affected.
-          setup_fixtures
-          setup_request rspec_api[:verb], rspec_api[:route], values
-          instance_eval(&block) if block_given?
-        end
-      end
-
-      def sets_of_parameters
-        [].tap do |sets_of_params|
-          sets_of_params.push no_params
-          if rspec_api[:callbacks]
-            rspec_api[:callbacks].each do |callback|
-              sets_of_params.push callback_params(callback)
-            end
-          end
-          if rspec_api[:array]
-            if rspec_api[:sorts]
-              rspec_api[:sorts].each do |sort|
-                sets_of_params.push sort_params(sort)
-              end
-            end
-            if rspec_api[:filters]
-              rspec_api[:filters].each do |filter|
-                sets_of_params.push filter_params(filter)
-              end
-            end
-            if rspec_api[:page]
-              sets_of_params.push page_params
-            end
-          end
-        end
-      end
-
-      def no_params
-        {} # always send the original request without extra parameters
-      end
-
-      def sort_params(sort)
-        {}.tap do |params|
-          params[sort[:name]] = sort[:value]
-          sort.fetch(:extra_fields, {}).each do |name, value|
-            params[name] = value
-          end
-        end
-      end
-
-      def page_params
-        {}.tap do |params|
-          params[rspec_api[:page][:name]] = rspec_api[:page][:value]
-        end
-      end
-
-      def filter_params(filter)
-        {}.tap do |params|
-          params[filter[:name]] = existing filter[:by]
-        end
-      end
-
-      def callback_params(callback)
-        {}.tap do |params|
-          params[callback[:name]] = callback[:value]
-        end
-      end
-
-      def setup_request(verb, route, values)
-        request = Proc.new {
-          interpolated_route, body = route.dup, values.dup
-          body.keys.each do |key|
-            if interpolated_route[":#{key}"]
-              value = body.delete(key)
-              value = value.call if value.is_a?(Proc)
-              interpolated_route[":#{key}"] = value.to_s
-              (@url_params ||= {})[key] = value
-            else
-              body[key] = body[key].call if body[key].is_a?(Proc)
-            end
-          end
-          [interpolated_route, body]
-        }
-        before(:all) { send_request verb, *instance_eval(&request) }
-      end
-
-      def request_description(text, values)
-        if values.empty?
-          'by default'
-        else
-          text = "with" unless text.present?
-          "#{text} #{values.map{|k,v| "#{k}#{" #{v}" unless v.is_a?(Proc)}"}.to_sentence}"
-        end
-      end
-
-      def parse_request_arguments(args)
-        text = args.first.is_a?(String) ? args[0] : ''
-        values = args.first.is_a?(String) ? args[1] : args[0]
-        [text, values || {}] # NOTE: In Ruby 2.0 we could write values.to_h
-      end
-    end
-  end
-end

data/lib/rspec-api/http/local.rb

@@ -1,11 +0,0 @@
-require 'rack/test'
-require 'rspec-api/http/local/route'
-require 'rspec-api/http/local/request'
-
-def app
-  Rails.application
-end
-
-RSpec.configuration.include Rack::Test::Methods, rspec_api_dsl: :route
-RSpec.configuration.include Http::Local::Route, rspec_api_dsl: :route
-RSpec.configuration.include Http::Local::Request, rspec_api_dsl: :request

data/lib/rspec-api/http/local/request.rb

@@ -1,15 +0,0 @@
-module Http
-  module Local
-    module Request
-      extend ActiveSupport::Concern
-
-      def response
-        last_response
-      end
-
-      def request_params
-        last_request.params
-      end
-    end
-  end
-end

data/lib/rspec-api/http/local/route.rb

@@ -1,12 +0,0 @@
-module Http
-  module Local
-    module Route
-      extend ActiveSupport::Concern
-
-      def send_request(verb, route, body)
-        header 'Accept', 'application/json'
-        send verb, route, body
-      end
-    end
-  end
-end

data/lib/rspec-api/http/remote.rb

@@ -1,23 +0,0 @@
-require 'faraday'
-require 'faraday_middleware' # TODO: use autoload, we only need EncodeJson
-require 'faraday-http-cache'
-
-# faraday-http-cache is a great gem that correctly ignores Private Cache
-# For the sake of saving Github calls, let's cache Private as well!
-module Faraday
-  class HttpCache
-    class CacheControl
-      def private?
-        false
-      end
-    end
-  end
-end
-
-require 'rspec-api/http/remote/resource'
-require 'rspec-api/http/remote/route'
-require 'rspec-api/http/remote/request'
-
-RSpec.configuration.include Http::Remote::Resource, rspec_api_dsl: :resource
-RSpec.configuration.include Http::Remote::Request, rspec_api_dsl: :request
-RSpec.configuration.include Http::Remote::Route, rspec_api_dsl: :route

data/lib/rspec-api/http/remote/request.rb

@@ -1,15 +0,0 @@
-module Http
-  module Remote
-    module Request
-      extend ActiveSupport::Concern
-
-      def response
-        @last_response
-      end
-
-      def request_params
-        @last_request.params
-      end
-    end
-  end
-end

data/lib/rspec-api/http/remote/resource.rb

@@ -1,13 +0,0 @@
-module Http
-  module Remote
-    module Resource
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def authorize_with(options = {})
-          rspec_api[:authorization] = options
-        end
-      end
-    end
-  end
-end