rspec-api 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5aca9f3d178f7137fee5b2a36a6687031421977
-  data.tar.gz: 59c9f1b202549efeaaa6d0f858da3ab8ffd9202e
+  metadata.gz: 5408552b4ac63e6bdbbd372c3c900c963f14ffbe
+  data.tar.gz: 53fa90f938352139f11677ae6b414fc32535ea47
 SHA512:
-  metadata.gz: 7b1daaed33cc5842157eed50faadb3f7660fb65ac13d699a0d16589b9b2029a0cf7515f6c29ecf8ba79e2b9e572cfefeffbf6d4f87e1b3f10bed7954a2a549e7
-  data.tar.gz: 506702acc31a909f7772a7e3ee15b0a66046fbff49f59f94f0408f6187b2b67448dc87c28cdd9939cddc0ab2f078b9ce28b47141b19f0004c89ac4b9ab95d738
+  metadata.gz: 8b86970f33d662320ac5189e82aa1117f1cf44d0ffe583a30c0cae3d4440181769e96cff3cfa7766fd75126d5227423931ffcbc0e3e9801bf123d776bbf53c58
+  data.tar.gz: dddc04c7ced68aa44e82856ce4b73187af7671cc7b6be7b33f1a72ff84f264895356e85542d6eaa3cf6a9974c18b62c2d30c72f8545ef4585b6a4ddd87860429

data/lib/rspec-api/active_resource.rb

@@ -0,0 +1,85 @@
+require 'faraday'
+
+module DSL
+  module ActiveResource
+    module Route
+      extend ActiveSupport::Concern
+
+      def send_request(verb, route, body)
+        conn = Faraday.new 'https://api.github.com/' do |c|
+          c.use Faraday::Response::Logger, Logger.new('log/faraday.log')
+          c.use Faraday::Adapter::NetHttp
+        end
+
+        conn.headers[:user_agent] = 'RSpec API for Github'
+        conn.authorization *authorization.flatten
+
+        @last_response = conn.send verb, route, (body.to_json if body.present?)
+      end
+
+      def authorization
+        # TODO: Any other way to access metadata in a before(:all) ?
+        self.class.metadata[:rspec_api][:authorization]
+      end
+
+      module ClassMethods
+
+        def setup_fixtures
+          # nothing to do for now...
+        end
+
+        def existing(field)
+          case field
+          when :user then 'claudiob'
+          when :gist_id then '0d7b597d822102148810'
+          when :id then '921225'
+          end
+        end
+
+        def unknown(field)
+          case field
+          when :user then 'not-a-valid-user'
+          when :gist_id then 'not-a-valid-gist-id'
+          when :id then 'not-a-valid-id'
+          end
+        end
+      end
+    end
+  end
+end
+
+
+module DSL
+  module ActiveResource
+    module Resource
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def authorize_with(options = {})
+          rspec_api[:authorization] = options
+        end
+      end
+    end
+  end
+end
+
+
+module DSL
+  module ActiveResource
+    module Request
+      extend ActiveSupport::Concern
+
+      def response
+        @last_response
+      end
+
+      def request_params
+        # TO DO
+      end
+    end
+  end
+end
+
+RSpec.configuration.include DSL::ActiveResource::Resource, rspec_api_dsl: :resource
+RSpec.configuration.include DSL::ActiveResource::Request, rspec_api_dsl: :request
+RSpec.configuration.include DSL::ActiveResource::Route, rspec_api_dsl: :route

data/lib/rspec-api/dsl.rb

@@ -1,8 +1,20 @@
-require 'rspec_api_documentation'
-require 'rspec_api_documentation/dsl'
-
-require 'rspec-api/accept_helper'
-require 'rspec-api/attributes_helper'
-require 'rspec-api/description_helper'
-require 'rspec-api/api_helper'
-require 'rspec-api/instances_helper'
+require 'rspec-api/dsl/resource'
+require 'rspec-api/dsl/get'
+require 'rspec-api/dsl/request'
+
+module DSL
+end
+
+def resource(name, args = {}, &block)
+  args.merge! rspec_api_dsl: :resource, rspec_api: {resource_name: name}
+  describe name, args, &block
+end
+
+def rspec_api
+  metadata[:rspec_api]
+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}

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

@@ -0,0 +1,93 @@
+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
+        extra_parameters.each do |params|
+          request_with_extra_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_extra_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 extra_parameters
+        [].tap do |optional_params|
+          optional_params << {} # default: no extra params
+          if rspec_api[:array]
+            if rspec_api[:sort]
+              optional_params << {sort: rspec_api[:sort][:parameter]}
+              optional_params << {sort: "-#{rspec_api[:sort][:parameter]}"}
+            end
+            if rspec_api[:page]
+              optional_params << {page: 2}
+            end
+            if rspec_api[:filter]
+              optional_params << {rspec_api[:filter][:parameter] => existing(rspec_api[:filter][:attribute])}
+            end
+          end
+        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
+              (@request_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.first : ''
+        values = args.first.is_a?(String) ? args.second : args.first
+        [text, values || {}] # NOTE: In Ruby 2.0 we could write values.to_h
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+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
+    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.exclude? status_code
+      end
+
+      def success?(status_code)
+        has_entity_body?(status_code) && status_code < 400
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'rspec-api/matchers'
+
+module DSL
+  module Request
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def should_match_body_expectations(status_code, &block)
+        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]
+        end
+        should_satisfy_expectations_in &block if block_given?
+      end
+
+    private
+
+      def should_return_a_json(is_array)
+        it { expect(response_body).to be_a_json(is_array ? Array : Hash) }
+      end
+
+      def should_include_fixture_data
+        it { expect(response_body).to include_fixture_data }
+      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_filtered_by(filter_options)
+        it {
+          if json_value = request_params[filter_options[:parameter].to_s]
+            expect(response_body).to be_filtered_by(filter_options[:attribute], json_value)
+          else
+            expect(response_body).to be_filtered_by(nil)
+          end
+        }
+      end
+
+      def should_satisfy_expectations_in(&block)
+        it { instance_exec(response_body, @request_params, &block) }
+      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
+        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
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'rspec-api/matchers'
+
+module DSL
+  module Request
+    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]) if rspec_api[:array] && rspec_api[:page]
+      end
+
+    private
+
+      def should_have_json_content_type
+        it { expect(response_headers).to have_json_content_type }
+      end
+
+      def should_be_paginated(page_parameter)
+        it { expect(response_headers).to have_pagination_links(request_params[page_parameter.to_s]) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'rspec-api/matchers'
+
+module DSL
+  module Request
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def should_match_status_expectations(status_code)
+        it { expect(response_status).to be_status status_code }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module DSL
+  module Resource
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      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 :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?
+      end
+
+      def accepts_page(page_parameter)
+        rspec_api[:page] = page_parameter
+      end
+
+      def accepts_sort(sort_parameter, options={})
+        rspec_api[:sort] = {parameter: sort_parameter, attribute: options[:on]}
+      end
+
+      # TODO: the second 'accepts_filter' should not override the first, but add
+      def accepts_filter(filter_parameter, options={})
+        rspec_api[:filter] = {parameter: filter_parameter, attribute: options[:on]}
+      end
+
+    private
+
+      def nested_attribute(name)
+        (@attribute_ancestors ||= []).push name
+        yield
+        @attribute_ancestors.pop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'rack/test'
+
+def app
+  Rails.application
+end
+
+module DSL
+  module RackTest
+    module Route
+      extend ActiveSupport::Concern
+
+      def send_request(verb, route, body)
+        header 'Accept', 'application/json'
+        send verb, route, body
+      end
+    end
+  end
+end
+
+
+module DSL
+  module RackTest
+    module Request
+      extend ActiveSupport::Concern
+
+      def response
+        last_response
+      end
+
+      def request_params
+        last_request.params
+      end
+    end
+  end
+end
+
+
+RSpec.configuration.include Rack::Test::Methods, rspec_api_dsl: :route
+RSpec.configuration.include DSL::RackTest::Route, rspec_api_dsl: :route
+RSpec.configuration.include DSL::RackTest::Request, rspec_api_dsl: :request

data/lib/rspec-api/matchers.rb

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+RSpec::Matchers.define :be_filtered_by do |filtered_attribute, json_value=nil|
+  match do |items|
+    if filtered_attribute.nil?
+      true
+    else
+      items.all?{|item| item[filtered_attribute.to_s].to_s == json_value}
+    end
+  end
+
+  description do
+    if filtered_attribute.nil?
+      %Q(not be filtered by any specific attribute)
+    else
+      %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

@@ -0,0 +1,16 @@
+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/page.rb

@@ -0,0 +1,20 @@
+RSpec::Matchers.define :have_pagination_links do |page|
+  match do |response_headers|
+    if page.nil?
+      true
+    else
+      links = response_headers['Link'] || '' # https://github.com/lostisland/faraday/pull/306
+      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

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

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

data/lib/rspec-api/version.rb

@@ -1,3 +1,3 @@
 module RspecApi
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rspec-api
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - claudiob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-04 00:00:00.000000000 Z
+date: 2013-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec-api-documentation
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -31,16 +31,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/rspec-api/accept_helper.rb
-- lib/rspec-api/api_helper.rb
-- lib/rspec-api/attributes_helper.rb
-- lib/rspec-api/description_helper.rb
+- lib/rspec-api/active_resource.rb
+- lib/rspec-api/dsl/get.rb
+- lib/rspec-api/dsl/request/body.rb
+- lib/rspec-api/dsl/request/headers.rb
+- lib/rspec-api/dsl/request/status.rb
+- lib/rspec-api/dsl/request.rb
+- lib/rspec-api/dsl/resource.rb
 - lib/rspec-api/dsl.rb
-- lib/rspec-api/instances_helper.rb
+- lib/rspec-api/http/rack_test.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/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
-homepage: https://github.com/claudiob/rspec-api
+homepage: https://github.com/rspec-api/rspec-api
 licenses:
 - MIT
 metadata: {}

data/lib/rspec-api/accept_helper.rb

@@ -1,61 +0,0 @@
-# encoding: UTF-8
-
-def accepts(options = {}, &block)
-  parameters = block_given? ? options.merge(block: block) : options
-  (metadata[:query_parameters] ||= []).push parameters
-end
-
-RSpec::Matchers.define :be_sorted_by do |attribute|
-  match do |items|
-    values = items.map{|item| item[attribute.to_s]}
-    values.reverse! if example.metadata[:request_params][:sort][0] == '-'
-    values == values.sort
-  end
-end
-
-def assert_pagination_links
-  expect(response_headers).to have_key 'Link'
-  links = response_headers['Link'].split(',')
-  rels = links.map{|link| link[/<.+?>; rel="(.*)"$/, 1]}
-  expect(rels).to match_array ['last', 'next']
-end
-
-def query_parameters_requests
-  metadata.fetch(:query_parameters, []).map do |params|
-    if params.has_key? :filter
-      filter_parameters_requests params
-    elsif params.has_key? :sort
-      sort_parameters_requests params
-    elsif params.has_key? :page
-      page_parameters_requests params
-    end
-  end.flatten
-end
-
-def filter_parameters_requests(params)
-  params.except(:given, :block).tap do |req|
-    value = params.fetch :given, apply(:as_json, to: existing(params[:on]))
-    req[:description] = " filtered by #{params[:filter]}"
-    req[:request_params] = {params[:filter] => value}
-    req[:block] = params[:block]
-  end
-end
-
-def sort_parameters_requests(params)
-  [true, false].map do |ascending|
-    params.except(:block).tap do |req|
-      req[:description] = " sorted by #{params[:sort]} #{ascending ? '↑' : '↓'}"
-      req[:request_params] = {sort: "#{ascending ? '' : '-'}#{params[:sort]}"}
-      req[:block] = params[:block]
-    end
-  end
-end
-
-def page_parameters_requests(params)
-  {}.tap do |req|
-    req[:description] = " paginated by #{params[:page]}"
-    (req[:request_params] = {})[params[:page]] = 1
-    req[:min_pages] = 2
-    req[:block] = -> _ { assert_pagination_links }
-  end
-end

data/lib/rspec-api/api_helper.rb

@@ -1,66 +0,0 @@
-shared_context 'accept_json', accepts: :json do
-  header 'Accept', 'application/json'
-end
-
-shared_context 'return_json', returns: :json do
-  after { expect(json_response?) }
-end
-
-def request(description, request_params = {})
-  default_request = {}
-  example_requests = [default_request]
-  example_requests.concat query_parameters_requests if metadata[:array]
-
-  example_requests.each do |request_metadata|
-    (request_metadata[:description] ||= '').prepend description
-    (request_metadata[:request_params] ||= {}).merge! request_params
-    metadata.merge! request_metadata
-    yield if block_given?
-  end
-end
-
-def request_params
-  example.metadata[:request_params]
-end
-
-def respond_with(expected_status, &block)
-  description = metadata[:description]
-  example description do
-    setup_instances
-    evaluate_request_params!
-    do_request request_params.dup
-    assert_response expected_status, &example.metadata.fetch(:block, block)
-  end
-end
-
-def assert_response(expected_status, &block)
-  assert_status expected_status
-  if block_given? || success? && returns_content?
-    json = JSON response_body
-    assert_attributes json if success?
-    assert_instances json
-    instance_exec(json, &block) if block_given?
-  end
-end
-
-def evaluate_request_params!
-  request_params.each do |name, value|
-    request_params[name] = instance_exec(&value) if value.is_a? Proc
-  end
-end
-
-def success?
-  status < 400
-end
-
-def returns_content?
-  [100, 101, 102, 204, 205, 304].exclude? status
-end
-
-def assert_status(expected_status)
-  expect(status).to be Rack::Utils.status_code(expected_status)
-end
-
-def json_response?
- response_headers['Content-Type'] == 'application/json; charset=utf-8'
-end

data/lib/rspec-api/attributes_helper.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'rspec_api_documentation/dsl'
-
-def has_attribute(name, type, options = {})
-  (metadata[:attributes] ||= {})[name] = options.merge(type: type)
-end
-
-def assert_attributes(json)
-  expect(json).to be_a (example.metadata[:array] ? Array : Hash)
-  example.metadata[:attributes].each do |name, options|
-    values = Array.wrap(json).map{|item| item[name.to_s]}
-    assert_attribute_types(values, options[:type], options[:can_be_nil])
-  end
-end
-
-def random_values_for_attributes
-  {}.tap do |values|
-    example.metadata[:attributes].each do |name, options|
-      can_be_nil = options[:can_be_nil] && (name != example.metadata[:on])
-      values[name] = random_attribute_value options.merge(can_be_nil: can_be_nil)
-    end
-  end
-end
-
-def random_attribute_value(options)
-  if options[:can_be_nil] && [true, false].sample
-    nil
-  else
-    case options[:type]
-      when :string then [*('a'..'z'), *('A'..'Z')].sample(Random.rand 32).join
-      when :integer then Random.rand(2**16)
-      when :url then "http://example.com/#{SecureRandom.urlsafe_base64}"
-    end
-  end
-end
-
-def assert_attribute_types(values, expected_type, can_be_nil)
-  values.compact! if can_be_nil
-  expect(values).to all_match_type expected_type
-end
-
-def matches_type?(value, type)
-  case type
-    when :url then value =~ URI::regexp
-    else value.is_a? type.to_s.classify.constantize
-  end
-end
-
-RSpec::Matchers.define :all_match_type do |type|
-  match do |values|
-    values.all? {|value| matches_type? value, type}
-  end
-end

data/lib/rspec-api/description_helper.rb

@@ -1,55 +0,0 @@
-def existing(key)
-  metadata[:description_attribute] = 'an existing'
-  -> { instances.any key }
-end
-
-def unknown(key)
-  metadata[:description_attribute] = 'an unknown'
-  -> { instances.none key }
-end
-
-def apply(method_name, options = {})
-  proc = options[:to]
-  -> { proc.call.send method_name }
-end
-
-def with(request_params = {})
-  request_params[:attribute] ||= metadata.delete :description_attribute
-  request description_for(request_params), request_params, &Proc.new
-end
-
-def no_params
-  {}
-end
-
-def valid(request_params)
-  request_params.merge attribute: 'an valid'
-end
-
-def invalid(request_params)
-  request_params.merge attribute: 'an invalid'
-end
-
-def description_for(request_params = {})
-  [description_verb, description_object(request_params)].join ' '
-end
-
-def description_verb
-  case metadata[:method]
-  when :get then 'Getting'
-  when :post then 'Creating'
-  when :put then 'Updating'
-  when :delete then 'Deleting'
-  end
-end
-
-def description_object(request_params = {})
-  attribute = request_params.delete :attribute
-  if metadata[:array]
-    "a list of #{metadata[:resource_name]}".tap do |objects|
-      objects << " by #{request_params.keys.join(', ')}" if request_params.any?
-    end
-  else
-    [attribute, metadata[:resource_name].singularize].join ' '
-  end.downcase
-end

data/lib/rspec-api/instances_helper.rb

@@ -1,37 +0,0 @@
-def setup_instances
-  instances.create random_values_for_attributes
-  instances.create random_values_for_attributes
-  stub_instances_total_pages example.metadata[:min_pages]
-end
-
-def instances
-  example.metadata[:resource_name].singularize.constantize
-end
-
-def assert_instances(json)
-  expect(json).not_to be_empty
-end
-
-def existing(key)
-  -> { instances.pluck(key).first }
-end
-
-def unknown(key)
-  keys = 0.downto(-Float::INFINITY).lazy
-  -> { keys.reject {|value| instances.exists? key => value}.first }
-end
-
-def apply(method_name, options = {})
-  proc = options[:to]
-  -> { proc.call.send method_name }
-end
-
-def stub_instances_total_pages(total_pages)
-  return unless instances.respond_to?(:page) and total_pages.present?
-  page_method = instances.method :page
-  instances.stub(:page) do |page|
-    page_method.call(page).tap do |proxy|
-      proxy.stub(:total_pages).and_return total_pages
-    end
-  end
-end