rspec-api 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc5683375460c14700afc17d12e045bb5acac528
-  data.tar.gz: c218c3741e024db99c24862a87092b5b4fe54594
+  metadata.gz: f66889873ee973973a2f419e950bd9f405abe7e2
+  data.tar.gz: bbd9a7c7f60d30eaad0e46a28de310e538933bc3
 SHA512:
-  metadata.gz: 1d9f72802f506ee2532df49b3d5e64b0cebb0535fc802f557b74e297c4996da73c80d1ded42dc6cdd44bd4e5a745c137df8823049ee1eabce14a96313f8f4050
-  data.tar.gz: e2d6254c1fe55f4a2ae6ce6086d92a734e5cdd3bfd905ac8090423a37278e40f71eb58c7d56ef4ad6528a183a21048506ff4033658a287fb5c1ad3f5834ee6c8
+  metadata.gz: 0bfaa8bfff6796c6620802a92505c7c4d89c29bfac3283123ab8d9aec942bb8805c02030434646898f119a36f817ca838b4182fcf776cfe02484af0e624a138e
+  data.tar.gz: 6eb04e4cd39cbf6275a1a8ce4e850996e3d27417bdd004947830ca1a11d484633fcb742636ea9c25f3d7f571b634b72efabc4f69a4dc0b4029c8dfa9a3e4ebb1

data/README.md

@@ -1,16 +1,102 @@
 RSpec API
 =========
 
-More info at [http://rspec-api.github.io](http://rspec-api.github.io)
+RSpec API aims to make it easy to document and test [pragmatic RESTful web APIs](http://www.vinaysahni.com/best-practices-for-a-pragmatic-restful-api).
 
-[![Build Status](https://travis-ci.org/rspec-api/rspec-api.png)](https://travis-ci.org/rspec-api/rspec-api)
+It is still under development, and you can follow its progress by checking out the code on Github.
+
+More documentation and examples are available at [http://rspec-api.github.io](http://rspec-api.github.io)
+
+[![Build Status](https://travis-ci.org/rspec-api/rspec-api.png?branch=master)](https://travis-ci.org/rspec-api/rspec-api)
 [![Code Climate](https://codeclimate.com/github/rspec-api/rspec-api.png)](https://codeclimate.com/github/rspec-api/rspec-api)
 [![Coverage Status](https://coveralls.io/repos/rspec-api/rspec-api/badge.png)](https://coveralls.io/r/rspec-api/rspec-api)
 [![Dependency Status](https://gemnasium.com/rspec-api/rspec-api.png)](https://gemnasium.com/rspec-api/rspec-api)
 
-How to test
-===========
+A basic example
+---------------
+
+RSpec API can help develop and document your own web APIs.
+A basic example of running RSpec API locally is provided, comprised of:
+
+* a Ruby on Rails *app* that provides a RESTful API for concerts (in [spec/dummy](https://github.com/rspec-api/rspec-api/tree/master/spec/dummy))
+* a *test suite* that verifies the expected behavior of the API (in [spec/features/local/](https://github.com/rspec-api/rspec-api/blob/master/spec/features/local/gigs/gigs_spec.rb))
+
+Run the basic example with the following commands:
+
+    git clone https://github.com/rspec-api/rspec-api.git
+    cd rspec-api
+    bundle
+    bundle exec rake db:migrate
+    bundle exec rspec spec/features/local
+
+And you should see all the successful promises matched by the concerts API:
+
+    Concerts
+      GET /concerts
+        by default
+          responds with a status code that
+            should be 200
+          responds with headers that
+            should include 'Content-Type': 'application/json; charset=utf-8'
+            should include 'Link' (for pagination)
+      ...
+      DELETE /concerts/:id
+        given an existing id
+          responds with a status code that
+            should be 204
+
+    Finished in 0.73864 seconds
+    151 examples, 0 failures
+
+
+The GitHub API example
+----------------------
+
+RSpec API can help specify and verify promises for remote APIs.
+An example of running RSpec API for a remote API is provided in [spec/features/remote](https://github.com/rspec-api/rspec-api/blob/master/spec/features/remote).
+The code verifies the expected behavior of a number of endpoints of the [GitHub API](http://developer.github.com):
+
+* Activity resources (events, feeds, notifications, starring, watching)
+* Gists resources (gists, gist comments)
+* Git data resources (blobs, commits)
+* Repository resources (repos)
+
+Before running the example, get a GitHub Personal Access Token:
+
+* Browse to your [GitHub settings](https://github.com/settings/applications)
+* Click on 'Create new token' under 'Personal Access Token' (name it as you want)
+* Copy the generated token and store it on your machine as the environment variable called `RSPEC_API_GITHUB_TOKEN`:
+  * On OSX and bash, accomplish this by running the command `export RSPEC_API_GITHUB_TOKEN=` followed by your pasted key (no spaces after `=`)
+
+Now, run the GitHub API example with the following commands:
+
+    git clone https://github.com/rspec-api/rspec-api.git
+    cd rspec-api
+    bundle
+    bundle exec rspec spec/features/remote
+
+And you should see all the successful promises matched by the GitHub API:
+
+    Events
+      GET https://api.github.com/events
+        by default
+          responds with a status code that
+            should be 200
+          responds with headers that
+            should include 'Content-Type': 'application/json; charset=utf-8'
+            should include 'Link' (for pagination)
+      ...
+      DELETE https://api.github.com/gists/:id/star
+        given an existing id 0d7b597d822102148810
+          responds with a status code that
+            should be 204
+
+    Finished in 1 minute 19.74 seconds
+    1237 examples, 1 failure, 4 pending
+
+How to contribute
+=================
+
+Don’t hesitate to send me code comments, issues or pull requests through GitHub!
+All feedback is appreciated. Thanks :)
 
-* Create a new [GitHub personal authentication token](https://github.com/settings/applications)
-* Store it in an environment variable called `RSPEC_API_GITHUB_TOKEN` (e.g., on OS X, type `export RSPEC_API_GITHUB_TOKEN=...`)
-* Run `rspec`

data/lib/rspec-api/dsl.rb

@@ -5,6 +5,11 @@ require 'rspec-api/dsl/request'
 module DSL
 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
@@ -13,4 +18,7 @@ end
 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
-# requires rspec >= 2.14 : RSpec.configuration.backtrace_exclusion_patterns << %r{lib/rspec-api/dsl\.rb}
+
+if RSpec::Core::Version::STRING >= '2.14'
+  RSpec.configuration.backtrace_exclusion_patterns << %r{lib/rspec-api/dsl\.rb}
+end

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

@@ -1,72 +1,5 @@
-require 'rack/utils'
+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'
-
-module DSL
-  module Request
-    extend ActiveSupport::Concern
-
-    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
-
-    def request_params
-      {} # To be overriden by more specific modules
-    end
-
-    module ClassMethods
-      def respond_with(status_symbol, &block)
-        status_code = to_code status_symbol
-
-        context 'responds with a status code that' do
-          should_match_status_expectations(status_code)
-        end
-        context 'responds with headers that' do
-          should_match_headers_expectations(status_code)
-        end
-        context 'responds with a body that' do
-          should_match_body_expectations(status_code, &block)
-        end
-      end
-
-    private
-
-      def to_code(status_symbol)
-        Rack::Utils.status_code status_symbol
-      end
-
-      def has_entity_body?(status_code)
-        !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status_code
-      end
-
-      def success?(status_code)
-        has_entity_body?(status_code) && status_code < 400
-      end
-    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
+require 'rspec-api/dsl/request/body'

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

@@ -1,3 +1,4 @@
+require 'active_support'
 require 'rspec-api/matchers'
 
 module DSL
@@ -5,85 +6,80 @@ module DSL
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def should_match_body_expectations(status_code, &block)
-        should_return_a_jsonp rspec_api[:callback] if rspec_api[:callback]
-        should_return_a_json rspec_api[:array] if success? status_code
-        should_include_attributes rspec_api.fetch(:attributes, {}) if success? status_code
-        if rspec_api[:array]
-          should_include_fixture_data unless rspec_api[:page]
-          should_be_sorted_by(rspec_api[:sort]) if rspec_api[:sort]
-          should_be_filtered_by(rspec_api[:filter]) if rspec_api[:filter]
+      # 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
-        should_satisfy_expectations_in &block if block_given?
-      end
-
-    private
-
-      def should_return_a_jsonp(callback_options)
-        it {
-          if callback_options[:value] == request_params[callback_options[:name].to_s]
-            expect(response_body).to be_a_jsonp(callback_options[:value])
-          else
-            expect(response_body).to be_a_jsonp(nil)
-          end
-        }
       end
+    end
 
-      def should_return_a_json(is_array)
-        it { expect(response_body).to be_a_json(is_array ? Array : Hash) }
-      end
+    def should_be_valid_json(type)
+      expect(response).to be_valid_json_if response_is_successful?, type
+    end
 
-      def should_include_fixture_data
-        it { expect(response_body).to include_fixture_data }
-      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_options)
-        it {
-          if sort_options[:parameter].to_s == request_params['sort']
-            expect(response_body).to be_sorted_by(sort_options[:attribute], verse: :asc)
-          elsif "-#{sort_options[:parameter].to_s}" == request_params['sort']
-            expect(response_body).to be_sorted_by(sort_options[:attribute], verse: :desc)
-          else
-            expect(response_body).to be_sorted_by(nil)
-          end
-        }
-      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_options)
-        it {
-          if json_value = request_params[filter_options[:name].to_s]
-            expect(response_body).to be_filtered_by(json_value, filter_options)
-          else
-            expect(response_body).to be_filtered_by(nil)
-          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_satisfy_expectations_in(&block)
-        it { instance_exec(response_body, @request_params, &block) }
-      end
+    def should_have_attributes(attributes)
+      expect(response).to have_attributes_if response_is_successful?, attributes
+    end
 
-      ## Attributes... might clean them up
-      def should_include_attributes(attributes, ancestors = [], can_be_nil=false)
-        attributes.each do |name, options = {}|
-          should_match_attributes name, options, ancestors, can_be_nil
-          should_include_nested_attributes name, options, ancestors
+    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 should_match_attributes(name, options, ancestors, can_be_nil)
-        it {
-          parent = ancestors.inject(response_body) do |chain, ancestor|
-            Array.wrap(chain).map{|item| item[ancestor.to_s]}.flatten
-          end
-          expect(parent).to have_attribute(name, options.merge(parent_can_be_nil: can_be_nil, parent_can_be_empty: true))
-        }
-      end
-
-      def should_include_nested_attributes(name, options, ancestors)
-        attributes = options.fetch :attributes, {}
-        should_include_attributes attributes, ancestors + [name], options[:can_be_nil]
-      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,3 +1,5 @@
+require 'active_support'
+require 'rack/utils'
 require 'rspec-api/matchers'
 
 module DSL
@@ -5,20 +7,34 @@ module DSL
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def should_match_headers_expectations(status_code)
-        should_have_json_content_type if has_entity_body? status_code
-        should_be_paginated(rspec_api[:page][:name]) if rspec_api[:array] && rspec_api[:page]
+      # 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
+  private
 
-      def should_have_json_content_type
-        it { expect(response_headers).to have_json_content_type }
-      end
+    def should_include_content_type(type)
+      expect(response).to include_content_type_if response_has_body?, type
+    end
 
-      def should_be_paginated(page_parameter)
-        it { expect(response_headers).to have_pagination_links(request_params[page_parameter.to_s]) }
-      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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,86 @@
+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,12 +1,17 @@
+require 'active_support'
 require 'rspec-api/matchers'
 
 module DSL
   module Request
-    extend ActiveSupport::Concern
+    extend ::ActiveSupport::Concern
 
     module ClassMethods
-      def should_match_status_expectations(status_code)
-        it { expect(response_status).to be_status status_code }
+      # 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

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

@@ -22,10 +22,30 @@ module DSL
       define_action :post
       define_action :delete
 
-      def has_attribute(name, type, options = {})
-        parent = (@attribute_ancestors || []).inject(rspec_api) {|chain, step| chain[:attributes][step]}
-        (parent[:attributes] ||= {})[name] = options.merge(type: type)
-        nested_attribute(name, &Proc.new) if block_given?
+
+      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)
@@ -33,25 +53,16 @@ module DSL
       end
 
       def accepts_sort(sort_parameter, options={})
-        rspec_api[:sort] = {name: sort_parameter, attribute: options[:on]}
+        (rspec_api[:sorts] ||= []) << options.merge(name: 'sort', value: sort_parameter)
       end
 
-      # TODO: the second 'accepts_filter' should not override the first, but add
       def accepts_filter(filter_parameter, options={})
-        rspec_api[:filter] = options.merge(name: filter_parameter)
+        (rspec_api[:filters] ||= []) << options.merge(name: filter_parameter)
       end
 
       def accepts_callback(callback_parameter)
-        rspec_api[:callback] = {name: callback_parameter, value: 'a_callback'}
-      end
-
-    private
-
-      def nested_attribute(name)
-        (@attribute_ancestors ||= []).push name
-        yield
-        @attribute_ancestors.pop
+        (rspec_api[:callbacks] ||= []) << {name: callback_parameter.to_s, value: 'a_callback'}
       end
     end
   end
-end
+end

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

@@ -44,12 +44,25 @@ module DSL
       def sets_of_parameters
         [].tap do |sets_of_params|
           sets_of_params.push no_params
-          sets_of_params.push callback_params if rspec_api[:callback]
+          if rspec_api[:callbacks]
+            rspec_api[:callbacks].each do |callback|
+              sets_of_params.push callback_params(callback)
+            end
+          end
           if rspec_api[:array]
-            sets_of_params.push sort_params(verse: :asc) if rspec_api[:sort]
-            sets_of_params.push sort_params(verse: :desc) if rspec_api[:sort]
-            sets_of_params.push page_params if rspec_api[:page]
-            sets_of_params.push filter_params if rspec_api[:filter]
+            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
@@ -58,10 +71,13 @@ module DSL
         {} # always send the original request without extra parameters
       end
 
-      def sort_params(options = {})
-        ascending = options[:verse] == :asc
-        sort = rspec_api[:sort][:name]
-        {sort: ascending ? "#{sort}" : "-#{sort}"}
+      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
@@ -70,15 +86,15 @@ module DSL
         end
       end
 
-      def filter_params
+      def filter_params(filter)
         {}.tap do |params|
-          params[rspec_api[:filter][:name]] = existing rspec_api[:filter][:on]
+          params[filter[:name]] = existing filter[:by]
         end
       end
 
-      def callback_params
+      def callback_params(callback)
         {}.tap do |params|
-          params[rspec_api[:callback][:name]] = rspec_api[:callback][:value]
+          params[callback[:name]] = callback[:value]
         end
       end
 
@@ -90,7 +106,7 @@ module DSL
               value = body.delete(key)
               value = value.call if value.is_a?(Proc)
               interpolated_route[":#{key}"] = value.to_s
-              (@request_params ||= {})[key] = value
+              (@url_params ||= {})[key] = value
             else
               body[key] = body[key].call if body[key].is_a?(Proc)
             end

data/lib/rspec-api/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-api
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - claudiob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-21 00:00:00.000000000 Z
+date: 2013-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-api-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -245,6 +259,8 @@ 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
@@ -257,17 +273,6 @@ files:
 - lib/rspec-api/http/remote/resource.rb
 - lib/rspec-api/http/remote/route.rb
 - lib/rspec-api/http/remote.rb
-- lib/rspec-api/matchers/attributes.rb
-- lib/rspec-api/matchers/body.rb
-- lib/rspec-api/matchers/content_type.rb
-- lib/rspec-api/matchers/fields.rb
-- lib/rspec-api/matchers/filter.rb
-- lib/rspec-api/matchers/fixtures.rb
-- lib/rspec-api/matchers/jsonp.rb
-- lib/rspec-api/matchers/page.rb
-- lib/rspec-api/matchers/sort.rb
-- lib/rspec-api/matchers/status.rb
-- lib/rspec-api/matchers.rb
 - lib/rspec-api/version.rb
 - MIT-LICENSE
 - README.md
@@ -291,7 +296,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: Methods to write more compact and meaningful, auto-documented specs for web

data/lib/rspec-api/matchers.rb

@@ -1,10 +0,0 @@
-require_relative 'matchers/status'
-require_relative 'matchers/body'
-require_relative 'matchers/content_type'
-require_relative 'matchers/fields'
-require_relative 'matchers/attributes'
-require_relative 'matchers/fixtures'
-require_relative 'matchers/page'
-require_relative 'matchers/sort'
-require_relative 'matchers/filter'
-require_relative 'matchers/jsonp'

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

@@ -1,33 +0,0 @@
-RSpec::Matchers.define :have_attribute do |name, options = {}|
-  name, can_be_nil, type = name.to_s, options[:can_be_nil], options[:type]
-
-  match do |json|
-    Array.wrap(json).all? do |item|
-      if (options[:parent_can_be_nil] and item.nil?) || (options[:parent_can_be_empty] and item.empty?)
-        true
-      elsif can_be_nil
-        item.key?(name)
-      else
-        matches_type?(item[name], type)
-      end
-    end
-  end
-
-  description do # TODO: add parent name
-    type = "#{options[:type]}#{' or nil' if can_be_nil}"
-    %Q(include the field #{name.to_json} of type #{type})
-  end
-
-  failure_message_for_should do |json|
-    %Q(should #{description}, but is #{json})
-  end
-end
-
-def matches_type?(value, type)
-  case type
-    when :url then value =~ URI::regexp
-    when :timestamp then DateTime.iso8601 value rescue false
-    when :boolean then [TrueClass, FalseClass].include? value.class
-    else value.is_a? type.to_s.classify.constantize
-  end
-end

data/lib/rspec-api/matchers/body.rb

@@ -1,13 +0,0 @@
-RSpec::Matchers.define :be_a_json do |expected_type|
-  match do |json|
-    json.is_a? expected_type
-  end
-
-  description do
-    "be a JSON #{expected_type}"
-  end
-
-  failure_message_for_should do |json|
-    %Q(should #{description}, but is #{json})
-  end
-end

data/lib/rspec-api/matchers/content_type.rb

@@ -1,13 +0,0 @@
-RSpec::Matchers.define :have_json_content_type do
-  match do |response|
-    response_headers['Content-Type'] == 'application/json; charset=utf-8'
-  end
-
-  description do
-    "include 'Content-Type': 'application/json; charset=utf-8'"
-  end
-
-  failure_message_for_should do |item|
-    %Q(should #{description}, but are #{response_headers})
-  end
-end

data/lib/rspec-api/matchers/fields.rb

@@ -1,32 +0,0 @@
-RSpec::Matchers.define :have_field do |key, options = {}|
-  value = options[:value]
-
-  match do |item|
-    item[key.to_s] == value
-  end
-
-  description do
-    %Q(have the value #{value.to_json} in the field #{key})
-  end
-
-  failure_message_for_should do |item|
-    %Q(should #{description}, but got #{item})
-  end
-end
-
-RSpec::Matchers.define :have_fields do |key, options = {}|
-  value = options[:value]
-  after = options[:after]
-
-  match do |items|
-    items.all?{|item| item[key.to_s].send(after) == value }
-  end
-
-  description do
-    %Q(have the value #{value.to_json} in the field #{key} after #{after})
-  end
-
-  failure_message_for_should do |items|
-    %Q(should #{description}, but got #{items})
-  end
-end

data/lib/rspec-api/matchers/filter.rb

@@ -1,28 +0,0 @@
-RSpec::Matchers.define :be_filtered_by do |json_value, options = {}|
-  filtered_attribute = options[:on]
-  compare = options[:comparing_with] || Proc.new{|x,y| x == y}
-
-  match do |items|
-    if filtered_attribute.nil?
-      true
-    else
-      items.all? do |item|
-        # TODO: Don't always use string
-        compare.call json_value, item[filtered_attribute.to_s].to_s
-      end
-    end
-  end
-
-  description do
-    if filtered_attribute.nil?
-      %Q(not be filtered by any specific attribute)
-    else
-      # TODO: Change description based on operator
-      %Q(be filtered by #{filtered_attribute.to_json} => #{json_value})
-    end
-  end
-
-  failure_message_for_should do |items|
-    %Q(should #{description}, but is #{items})
-  end
-end

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

@@ -1,16 +0,0 @@
-RSpec::Matchers.define :include_fixture_data do
-  match do |body|
-    if body.empty? #&& did_not_declare_fixtures
-      pending 'Make your tests more meaningful by declaring fixtures!'
-    end
-    !body.empty?
-  end
-
-  description do
-    %Q(have some values from the fixtures)
-  end
-
-  failure_message_for_should do |response|
-    %Q(should #{description}, but got an empty array)
-  end
-end

data/lib/rspec-api/matchers/jsonp.rb

@@ -1,17 +0,0 @@
-RSpec::Matchers.define :be_a_jsonp do |callback_name|
-  match do |response_body|
-    if callback_name.nil?
-      true
-    else
-      response.body =~ %r[^#{callback_name}\((.*?)\)$]
-    end
-  end
-
-  description do
-    %Q(be a JSONP callback)
-  end
-
-  failure_message_for_should do |response_body|
-    %Q(should #{description}, but is #{response_body})
-  end
-end

data/lib/rspec-api/matchers/page.rb

@@ -1,19 +0,0 @@
-RSpec::Matchers.define :have_pagination_links do |page|
-  match do |response_headers|
-    if page.nil?
-      true
-    else
-      links = response_headers['Link'] || '' # see http://git.io/CUz3-Q
-      rels = links.split(',').map{|link| link[/<.+?>; rel="(.*)"$/, 1]}
-      rels.sort == ['first', 'prev']
-    end
-  end
-
-  description do
-    %Q(include 'Link' (for pagination))
-  end
-
-  failure_message_for_should do |response_headers|
-    %Q(should #{description}, but are #{response_headers})
-  end
-end

data/lib/rspec-api/matchers/sort.rb

@@ -1,25 +0,0 @@
-RSpec::Matchers.define :be_sorted_by do |sorting_field, options = {}|
-  match do |items|
-    if sorting_field.nil?
-      true
-    else
-      values = items.map{|item| item[sorting_field.to_s]}
-      values.reverse! if options[:verse] == :desc
-      values == values.sort
-    end
-  end
-
-  description do
-    # NOTE: Since `accepts_sort random: nil` is acceptable, this description
-    # should say "you should not expect any sorting by any specific field"
-    if sorting_field.nil?
-      %Q(not be sorted by any specific attribute)
-    else
-      %Q(be sorted by #{sorting_field.to_json} #{options[:verse]})
-    end
-  end
-
-  failure_message_for_should do |items|
-    %Q(should #{description}, but is #{items})
-  end
-end

data/lib/rspec-api/matchers/status.rb

@@ -1,13 +0,0 @@
-RSpec::Matchers.define :be_status do |expected|
-  match do |actual|
-    actual == expected
-  end
-
-  description do
-    %Q(be #{expected})
-  end
-
-  failure_message_for_should do |actual|
-    %Q(should #{description}, but is #{actual})
-  end
-end