restspec 0.0.1

data/examples/store-api/spec/views/products/show.html.erb_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+RSpec.describe "products/show", :type => :view do
+  before(:each) do
+    @product = assign(:product, Product.create!(
+      :name => "Name",
+      :code => "Code",
+      :price => "9.99"
+    ))
+  end
+
+  it "renders attributes in <p>" do
+    render
+    expect(rendered).to match(/Name/)
+    expect(rendered).to match(/Code/)
+    expect(rendered).to match(/9.99/)
+  end
+end

data/lib/restspec.rb

@@ -0,0 +1,38 @@
+require "restspec/version"
+
+module Restspec
+end
+
+require 'active_support/core_ext/object'
+
+require "restspec/values/status_code"
+require "restspec/values/super_hash"
+
+require "restspec/configuration"
+require "restspec/stores/namespace_store"
+require "restspec/stores/endpoint_store"
+require "restspec/stores/schema_store"
+require "restspec/shortcuts"
+
+require "restspec/schema/checker"
+require "restspec/schema/types"
+require "restspec/schema/attribute"
+require "restspec/schema/attribute_example"
+require "restspec/schema/schema_example"
+require "restspec/schema/schema"
+require "restspec/schema/dsl"
+
+require "restspec/endpoints/dsl"
+require "restspec/endpoints/request"
+require "restspec/endpoints/response"
+require "restspec/endpoints/network"
+require "restspec/endpoints/endpoint"
+require "restspec/endpoints/namespace"
+
+require "restspec/requirements/dsl"
+require "restspec/requirements/requirement"
+
+require "restspec/rspec/extras"
+require "restspec/rspec/api_helpers"
+require "restspec/rspec/api_macros"
+require "restspec/rspec/shared_examples"

data/lib/restspec/configuration.rb

@@ -0,0 +1,43 @@
+require 'active_support/configurable'
+
+module Restspec
+  include ActiveSupport::Configurable
+
+  class << self
+    def configure
+      config.request = OpenStruct.new(headers: {})
+      config.request.headers['Content-Type'] = 'application/json'
+      config.request.headers['Accept'] = 'application/json'
+
+      config.custom = OpenStruct.new
+
+      yield config
+
+      populate_stores
+    end
+
+    def populate_stores
+      load_schemas
+      load_endpoint_definition
+      load_requirement_definition
+    end
+
+    private
+
+    def load_schemas
+      eval_file Schema::DSL.new, config.schema_definition
+    end
+
+    def load_endpoint_definition
+      eval_file Endpoints::DSL.new, config.endpoints_definition
+    end
+
+    def load_requirement_definition
+      eval_file Requirements::DSL.new, config.requirements_definition
+    end
+
+    def eval_file(object, file_name)
+      object.instance_eval(File.read(file_name)) if file_name.present?
+    end
+  end
+end

data/lib/restspec/endpoints/dsl.rb

@@ -0,0 +1,142 @@
+require 'active_support/inflector'
+
+module Restspec
+  module Endpoints
+    HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head]
+
+    class DSL
+      def namespace(name, base_path: nil, &block)
+        namespace = Namespace.create(name.to_s)
+        namespace.base_path = base_path
+        namespace_dsl = NamespaceDSL.new(namespace)
+        namespace_dsl.instance_eval(&block)
+      end
+
+      def resource(name, options = {}, &block)
+        namespace name, base_path: (options[:base_path] || "/#{name}") do
+          if self.namespace.schema_name.blank?
+            schema_name = name.to_s.singularize
+            schema(schema_name.to_sym)
+          end
+
+          instance_eval(&block)
+        end
+      end
+    end
+
+    class NamespaceDSL
+      attr_accessor :namespace, :endpoint_base_path, :resource_endpoint_base_path, :common_endpoints_config_block
+
+      def initialize(namespace)
+        self.namespace = namespace
+        self.resource_endpoint_base_path = ''
+      end
+
+      def endpoint(name, &block)
+        endpoint = Endpoint.new(name)
+        endpoint_dsl = EndpointDSL.new(endpoint)
+        namespace.add_endpoint(endpoint)
+
+        endpoint_dsl.instance_eval(&block)
+        endpoint_dsl.instance_eval(&common_endpoints_config_block)
+
+        Restspec::EndpointStore.store(endpoint)
+      end
+
+      HTTP_METHODS.each do |http_method|
+        define_method(http_method) do |name, path = '', &block|
+          endpoint(name) do
+            public_send(http_method, path)
+            instance_eval(&block) if block.present?
+          end
+        end
+      end
+
+      def member(base_path: nil, identifier_name: 'id', &block)
+        member_namespace = namespace.add_anonymous_children_namespace
+        member_namespace.base_path = base_path || "/:#{identifier_name}"
+        NamespaceDSL.new(member_namespace).instance_eval(&block)
+      end
+
+      def collection(base_path: nil, &block)
+        collection_namespace = namespace.add_anonymous_children_namespace
+        collection_namespace.base_path = base_path
+        NamespaceDSL.new(collection_namespace).instance_eval(&block)
+      end
+
+      def schema(name, schema_extensions = {})
+        namespace.schema_name = name
+        namespace.schema_extensions = schema_extensions
+      end
+
+      def all(&endpoints_config)
+        self.common_endpoints_config_block = endpoints_config
+      end
+
+      def url_param(param, &value_or_example_block)
+        all do
+          url_param(param, &value_or_example_block)
+        end
+      end
+
+      private
+
+      def common_endpoints_config_block
+        @common_endpoints_config_block ||= (Proc.new {})
+      end
+    end
+
+    class EndpointDSL < Struct.new(:endpoint)
+      def method(method)
+        endpoint.method = method
+      end
+
+      def path(path)
+        endpoint.path = path
+      end
+
+      def schema(name, schema_extensions = {})
+        endpoint.schema_name = name
+        endpoint.schema_extensions = schema_extensions
+      end
+
+      def headers
+        endpoint.headers
+      end
+
+      def url_param(param, &value_or_type_block)
+        endpoint.add_url_param_block(param) do
+          value_or_type_context = ValueOrTypeContext.new
+          value_or_type = value_or_type_context.instance_eval(&value_or_type_block)
+
+          if value_or_type.is_a?(Restspec::Schema::Types::BasicType)
+            attribute = if endpoint.schema && endpoint.schema.attributes[param]
+              endpoint.schema.attributes[param]
+            else
+              Restspec::Schema::Attribute.new(param, value_or_type_context.integer)
+            end
+
+            value_or_type.example_for(attribute)
+          else
+            value_or_type
+          end
+        end
+      end
+
+      HTTP_METHODS.each do |http_method|
+        define_method(http_method) do |path|
+          self.method http_method
+          self.path path
+        end
+      end
+    end
+
+    class ValueOrTypeContext
+      Restspec::Schema::Types::ALL.each do |type_name, type_class|
+        define_method(type_name) do |options = {}|
+          type_class.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/restspec/endpoints/endpoint.rb

@@ -0,0 +1,135 @@
+require 'httparty'
+
+module Restspec
+  module Endpoints
+    class Endpoint < Struct.new(:name)
+      attr_accessor :method, :path, :namespace, :raw_url_params, :schema_extensions
+      attr_writer :schema_name
+      attr_reader :last_response, :last_request
+
+      PARAM_INTERPOLATION_REGEX = /:([\w]+)/
+
+      def execute(body: {}, url_params: {}, query_params: {})
+        full_url = build_full_url(url_params, query_params)
+        request = Request.new(method, full_url, full_headers, body)
+
+        Network.request(request).tap do |response|
+          self.last_request = inject_self_into(response, :endpoint)
+          self.last_request = inject_self_into(request, :endpoint)
+        end
+      end
+
+      def execute_once(body: {}, url_params: {}, query_params: {}, before: ->{ })
+        @executed_response ||= begin
+          before.call
+          execute(body: body, url_params: url_params, query_params: query_params)
+        end
+      end
+
+      def full_name
+        [namespace.try(:name), name].compact.join("/")
+      end
+
+      def schema_name
+        @schema_name || namespace.try(:schema_name)
+      end
+
+      def schema
+        @schema ||= begin
+          found_schema = schema_from_store
+          if found_schema.present?
+            found_schema.clone.extend_with(schema_extensions || {})
+          else
+            nil
+          end
+        end
+      end
+
+      def full_path
+        if namespace && in_member_or_collection?
+          "#{namespace.full_base_path}#{path}"
+        else
+          path
+        end
+      end
+
+      def headers
+        @headers ||= {}
+      end
+
+      def url_params
+        @url_params ||= Restspec::Values::SuperHash.new(calculate_url_params)
+      end
+
+      def add_url_param_block(param, &block)
+        raw_url_params[param] = Proc.new(&block)
+      end
+
+      def executed_url
+        last_request.url
+      end
+
+      private
+
+      attr_writer :last_response, :last_request
+
+      def schema_from_store
+        Restspec::SchemaStore.get(schema_name)
+      end
+
+      def inject_self_into(object, property)
+        object.tap { object.send(:"#{property}=", self) }
+      end
+
+      def build_full_url(url_params, query_params)
+        full_url_params = self.url_params.merge(Values::SuperHash.new(url_params))
+        build_url(full_url_params, query_params)
+      end
+
+      def raw_url_params
+        @raw_url_params ||= Restspec::Values::SuperHash.new
+      end
+
+      def in_member_or_collection?
+        namespace.anonymous?
+      end
+
+      def calculate_url_params
+        raw_url_params.inject({}) do |hash, (key, value)|
+          real_value = if value.respond_to?(:call)
+            value.call
+          else
+            value
+          end
+
+          hash.merge(key.to_sym => real_value)
+        end
+      end
+
+      def build_url(full_url_params, query_params)
+        query_string = query_params.to_param
+        full_query_string = query_string.present? ? "?#{query_string}" : ""
+
+        base_url + path_from_params(full_url_params) + full_query_string
+      end
+
+      def path_from_params(url_params)
+        full_path.gsub(PARAM_INTERPOLATION_REGEX) do
+          url_params[$1] || url_params[$1.to_sym]
+        end
+      end
+
+      def full_headers
+        config_headers.merge(headers)
+      end
+
+      def config_headers
+        Restspec.config.try(:request).try(:headers) || {}
+      end
+
+      def base_url
+        @base_url ||= (Restspec.config.base_url || '')
+      end
+    end
+  end
+end

data/lib/restspec/endpoints/namespace.rb

@@ -0,0 +1,89 @@
+module Restspec
+  module Endpoints
+    class Namespace
+      attr_accessor :base_path, :parent_namespace, :children_namespaces, :schema_extensions
+      attr_writer :schema_name
+      attr_reader :endpoints
+
+      def self.create(name = '')
+        namespace = new(name)
+        Stores::NamespaceStore.store(namespace)
+        namespace
+      end
+
+      def initialize(name = '')
+        self.name = name
+        self.endpoints = []
+        self.children_namespaces = []
+      end
+
+      def add_anonymous_children_namespace
+        anonymous_namespace = Namespace.create
+        anonymous_namespace.parent_namespace = self
+        children_namespaces << anonymous_namespace
+        anonymous_namespace
+      end
+
+      def add_endpoint(endpoint)
+        endpoint.namespace = self
+        endpoints << endpoint
+        endpoint
+      end
+
+      def get_endpoint(endpoint_name)
+        search_internal_endpoint(endpoint_name) || search_child_endpoint(endpoint_name)
+      end
+
+      def top_level_namespace?
+        parent_namespace.nil?
+      end
+
+      def full_base_path
+        if top_level_namespace?
+          base_path
+        else
+          parent_namespace.full_base_path + base_path
+        end
+      end
+
+      def schema_name
+        @schema_name || parent_namespace.try(:schema_name)
+      end
+
+      def name
+        if top_level_namespace?
+          @name
+        else
+          [parent_namespace.name, @name].reject(&:blank?).join('/')
+        end
+      end
+
+      def anonymous?
+        @name.blank?
+      end
+
+      private
+
+      attr_writer :name, :endpoints
+
+      def search_internal_endpoint(endpoint_name)
+        endpoints.find do |endpoint|
+          endpoint.name == endpoint_name
+        end
+      end
+
+      def search_child_endpoint(endpoint_name)
+        children_namespaces.each do |children_namespace|
+          child_endpoint = children_namespace.get_endpoint(endpoint_name)
+          return child_endpoint if child_endpoint.present?
+        end
+
+        return nil
+      end
+
+      def base_path
+        @base_path ||= ''
+      end
+    end
+  end
+end