restspec 0.0.1

data/lib/restspec/endpoints/network.rb

@@ -0,0 +1,39 @@
+module Restspec
+  module Endpoints
+    module Network
+      extend self
+
+      def request(request_object)
+        code, headers, body = network_adapter.request(request_object)
+        Response.new(code, headers, body)
+      end
+
+      private
+
+      def network_adapter
+        network_adapter_lambda.try(:call) || default_network_adapter
+      end
+
+      def network_adapter_lambda
+        Restspec.config.request.network_adapter
+      end
+
+      def default_network_adapter
+        HTTPartyNetworkAdapter.new
+      end
+
+      class HTTPartyNetworkAdapter
+        def request(request_object)
+          response = HTTParty.send(
+            request_object.method,
+            request_object.url,
+            headers: request_object.headers,
+            body: request_object.raw_payload
+          )
+
+          [response.code, response.headers, response.body]
+        end
+      end
+    end
+  end
+end

data/lib/restspec/endpoints/request.rb

@@ -0,0 +1,11 @@
+module Restspec
+  module Endpoints
+    class Request < Struct.new(:method, :url, :headers, :payload)
+      attr_accessor :endpoint
+
+      def raw_payload
+        @raw_payload ||= (payload || '').to_json
+      end
+    end
+  end
+end

data/lib/restspec/endpoints/response.rb

@@ -0,0 +1,53 @@
+require 'delegate'
+
+module Restspec
+  module Endpoints
+    class Response
+      attr_accessor :endpoint, :headers, :code, :raw_body
+
+      def initialize(code, headers, raw_body)
+        self.headers = headers
+        self.code = code
+        self.raw_body = raw_body
+      end
+
+      def to_s
+        if endpoint.present?
+          url = endpoint.executed_url || endpoint.full_path
+          "[#{endpoint.method.upcase} to #{url}]"
+        else
+          raw_body
+        end
+      end
+
+      def read_body(value = parsed_body)
+        case value
+        when Array
+          value.map { |item| read_body(item) }
+        when Hash
+          Values::SuperHash.new(value).tap do |super_hash|
+            super_hash.find do |key, value|
+              if value.class == Array
+                super_hash[key] = read_body(value)
+              end
+            end
+          end
+        else
+          value
+        end
+      end
+
+      def parsed_body
+        @parsed_body ||= begin
+          JSON.parse(raw_body)
+        rescue JSON::ParserError => e
+          raw_body
+        end
+      end
+
+      def body
+        @body ||= read_body
+      end
+    end
+  end
+end

data/lib/restspec/requirements/dsl.rb

@@ -0,0 +1,10 @@
+module Restspec
+  module Requirements
+    class DSL
+      def requirement(name, &definition)
+        requirement = Requirement.get_or_create(name)
+        requirement.instance_eval(&definition)
+      end
+    end
+  end
+end

data/lib/restspec/requirements/requirement.rb

@@ -0,0 +1,59 @@
+module Restspec
+  module Requirements
+    class Requirement
+      attr_reader :name, :errors
+
+      def initialize(name)
+        self.name = name
+        self.errors = []
+        extend Restspec::RSpec::ApiHelpers
+      end
+
+      def execution(&execution_block)
+        define_singleton_method(:execute, &execution_block)
+      end
+
+      def execute
+      end
+
+      def assert!
+        execute
+        if errors.any?
+          raise errors.join(' | ')
+        end
+      end
+
+      def add_error(error)
+        errors << error
+      end
+
+      private
+
+      attr_writer :name, :errors
+
+      class << self
+        attr_reader :requirements
+
+        def get_or_create(name)
+          find_by_name(name) || create(name)
+        end
+
+        def find_by_name(name)
+          requirements.find { |r| r.name == name }
+        end
+
+        def create(name)
+          self.new(name).tap { |r| requirements << r }
+        end
+
+        def requirements
+          @requirements ||= []
+        end
+
+        private
+
+        attr_writer :requirements
+      end
+    end
+  end
+end

data/lib/restspec/rspec/api_helpers.rb

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/object'
+
+module Restspec
+  module RSpec
+    module ApiHelpers
+      def read_endpoint(endpoint_full_name = nil, options = {})
+        call_endpoint(endpoint_full_name, options).read_body
+      end
+
+      def call_endpoint(endpoint_full_name = nil, body: {},
+                                            url_params: {},
+                                            query_params: {},
+                                            merge_example_params: true,
+                                            execution_method: :execute)
+        endpoint = find_endpoint_in_test_context(endpoint_full_name)
+
+        if merge_example_params
+          query_params = (@query_params || {}).merge(query_params)
+          url_params = (@url_params || {}).merge(url_params)
+        end
+
+        endpoint.send(execution_method, body: body, url_params: url_params, query_params: query_params)
+      end
+
+      def find_endpoint_in_test_context(endpoint_full_name)
+        if endpoint_full_name.present?
+          test_context = self.class
+
+          test_context.metadata[:endpoints] ||= {}
+          test_context.metadata[:endpoints][endpoint_full_name] ||= begin
+            Restspec::EndpointStore.get(endpoint_full_name)
+          end
+        else
+          endpoint
+        end
+      end
+
+      def read_endpoint_once(endpoint_full_name = nil, options = {})
+        call_endpoint_once(endpoint_full_name, options).read_body
+      end
+
+      def call_endpoint_once(endpoint_full_name = nil, options = {})
+        call_endpoint(endpoint_full_name, options.merge(:execution_method => :execute_once))
+      end
+
+      def execute_endpoint!
+        execute_endpoint_lambda.call
+        response
+      end
+
+      def schema_example(schema_name = nil)
+        if schema_name.nil? && endpoint.present?
+          schema_name = endpoint.schema_name
+        end
+
+        Restspec.example_for(schema_name)
+      end
+
+      def self.included(base)
+        base.extend(self)
+      end
+    end
+  end
+end

data/lib/restspec/rspec/api_macros.rb

@@ -0,0 +1,126 @@
+require_relative './matchers/api_matchers'
+
+module Restspec
+  module RSpec
+    module ApiMacros
+      def endpoint(name, options = {}, &block)
+        endpoint = Restspec::EndpointStore.get(name).dup
+
+        implicit_test = options[:implicit_test]
+
+        self.metadata[:current_endpoint_template] = endpoint
+        self.metadata[:resource_endpoint] = Restspec::EndpointStore.get(options[:resource])
+
+        describe "[#{endpoint.method.to_s.upcase} #{endpoint.name}]", options do
+          implicit_test ? test(&block) : instance_eval(&block)
+        end
+      end
+
+      def test(message = 'the happy path', options = {}, &test_body)
+        endpoint_context = self
+        endpoint_context.metadata[:before_callbacks] = []
+
+        context(message, options) do
+          test_context = self
+
+          let(:endpoint) do
+            endpoint_block_endpoint = endpoint_context.metadata[:current_endpoint_template]
+            test_context.metadata[:current_endpoint] ||= endpoint_block_endpoint.clone
+          end
+
+          before { response }
+
+          let(:response) do
+            @response = execute_endpoint_lambda.call
+          end
+
+          let(:request) do
+            endpoint.last_request
+          end
+
+          let(:resource_endpoint) do
+            test_context.metadata[:resource_endpoint]
+          end
+
+          let(:initial_resource) do
+            test_context.metadata[:initial_resource] ||= begin
+              resource_endpoint.try(:execute).try(:body)
+            end
+          end
+
+          let(:final_resource) { body }
+
+          let(:execute_endpoint_lambda) do
+            resource_params = resource_endpoint.try(:url_params) || {}
+            before_callbacks = test_context.metadata[:before_callbacks]
+
+            -> do
+              endpoint.execute_once(
+                body: payload.merge(@payload || {}),
+                url_params: url_params.merge(resource_params).merge(@url_params || {}),
+                query_params: query_params.merge(@query_params || {}),
+                before: ->do
+                  before_callbacks.each { |callback| instance_eval(&callback) }
+                  initial_resource
+                end
+              )
+            end
+          end
+
+          let(:body) { response.body }
+
+          subject { response }
+
+          let(:payload) do
+            defined?(example_payload) ? example_payload : {}
+          end
+
+          let(:url_params) do
+            defined?(example_url_params) ? example_url_params : {}
+          end
+
+          let(:query_params) do
+            defined?(example_query_params) ? example_query_params : {}
+          end
+
+          instance_eval(&test_body)
+        end
+      end
+
+      def before_test(&block)
+        metadata[:before_callbacks] << block
+      end
+
+      def payload(params = {}, &payload_block)
+        let(:example_payload) do
+          payload_params = payload_block.present? ? instance_eval(&payload_block) : {}
+          Restspec::Values::SuperHash.new(params.merge(payload_params))
+        end
+      end
+
+      def url_params(params = nil, &params_block)
+        let(:example_url_params) do
+          Restspec::Values::SuperHash.new(params || instance_eval(&params_block))
+        end
+      end
+
+      def query_params(params = nil, &params_block)
+        let(:example_query_params) do
+          Restspec::Values::SuperHash.new(params || instance_eval(&params_block))
+        end
+      end
+
+      def ensure!(name)
+        requirement = Restspec::Requirements::Requirement.find_by_name(name)
+        requirement.assert!
+      end
+
+      def within_response(&block)
+        context 'within response' do
+          subject { response.body }
+          instance_eval(&block)
+        end
+      end
+    end
+  end
+end

data/lib/restspec/rspec/extras.rb

@@ -0,0 +1,2 @@
+require 'rspec/its'
+require 'rspec/collection_matchers'

data/lib/restspec/rspec/matchers/api_matchers.rb

@@ -0,0 +1,6 @@
+require 'rspec/expectations'
+require_relative './have_status'
+require_relative './have_header'
+require_relative './be_like_schema'
+require_relative './be_like_schema_array'
+require_relative './include_where'

data/lib/restspec/rspec/matchers/be_like_schema.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :be_like_schema do |schema_name = nil|
+  match do |response|
+    schema = if schema_name.present?
+      Restspec::SchemaStore.get(schema_name)
+    else
+      response.endpoint.schema
+    end
+
+    body = response.respond_to?(:body) ? response.body : response
+    checker_for(schema).check!(body)
+  end
+
+  private
+
+  def checker_for(schema)
+    Restspec::Schema::Checker.new(schema)
+  end
+end

data/lib/restspec/rspec/matchers/be_like_schema_array.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :be_like_schema_array do |schema_name = nil|
+  match do |response|
+    schema = if schema_name.present?
+      Restspec::SchemaStore.get(schema_name)
+    else
+      response.endpoint.schema
+    end
+
+    body = response.respond_to?(:body) ? response.body : response
+    checker_for(schema).check_array!(body)
+  end
+
+  private
+
+  def checker_for(schema)
+    Restspec::Schema::Checker.new(schema)
+  end
+end

data/lib/restspec/rspec/matchers/have_header.rb

@@ -0,0 +1,47 @@
+RSpec::Matchers.define :have_header do |key|
+  match do |response|
+    chained_test.perform(key, response.headers)
+  end
+
+  chain :equals do |expected_header_value|
+    @chained_test = Restspec::HeaderTests::EqualsTest.new(expected_header_value)
+  end
+
+  chain :that_contains do |expected_header_part|
+    @chained_test = Restspec::HeaderTests::ContainsTest.new(expected_header_part)
+  end
+
+  chain :that_matches do |expected_header_regex|
+    @chained_test = Restspec::HeaderTests::MatchesTest.new(expected_header_regex)
+  end
+
+  def chained_test
+    @chained_test ||= Restspec::HeaderTests::HaveKeyTest.new
+  end
+end
+
+module Restspec::HeaderTests
+  class HaveKeyTest
+    def perform(key, headers)
+      headers.has_key?(key)
+    end
+  end
+
+  class EqualsTest < Struct.new(:expected_header_value)
+    def perform(key, headers)
+      headers.fetch(key) == expected_header_value
+    end
+  end
+
+  class ContainsTest < Struct.new(:expected_header_part)
+    def perform(key, headers)
+      headers.fetch(key).include? expected_header_part
+    end
+  end
+
+  class MatchesTest < Struct.new(:expected_header_regex)
+    def perform(key, headers)
+      headers.fetch(key).match(expected_header_regex).present?
+    end
+  end
+end