restspec 0.0.1

data/lib/restspec/schema/types/hash_type.rb

@@ -0,0 +1,25 @@
+module Restspec::Schema::Types
+  class HashType < BasicType
+    def example_for(attribute)
+      {}
+    end
+
+    def valid?(attribute, value)
+      is_hash = value.is_a?(Hash)
+      keys = schema_options.fetch(:keys, [])
+
+      if keys.empty?
+        is_hash
+      else
+        value_type = schema_options.fetch(:value_type, nil)
+
+        is_hash && keys.all? do |key|
+          has_key = value.has_key?(key)
+          if has_key && value_type
+            has_key && value_type.totally_valid?(attribute, value[key])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restspec/schema/types/integer_type.rb

@@ -0,0 +1,11 @@
+module Restspec::Schema::Types
+  class IntegerType < BasicType
+    def example_for(attribute)
+      Faker::Number.digit
+    end
+
+    def valid?(attribute, value)
+      value.is_a?(Fixnum)
+    end
+  end
+end

data/lib/restspec/schema/types/null_type.rb

@@ -0,0 +1,11 @@
+module Restspec::Schema::Types
+  class NullType < BasicType
+    def example_for(attribute)
+      nil
+    end
+
+    def valid?(attribute, value)
+      value.nil?
+    end
+  end
+end

data/lib/restspec/schema/types/one_of_type.rb

@@ -0,0 +1,21 @@
+module Restspec::Schema::Types
+  class OneOfType < BasicType
+    def example_for(attribute)
+      elements.sample
+    end
+
+    def valid?(attribute, value)
+      elements.include?(value)
+    end
+
+    def to_s
+      "OneOfType(#{elements})"
+    end
+
+    private
+
+    def elements
+      options.fetch(:elements)
+    end
+  end
+end

data/lib/restspec/schema/types/schema_id_type.rb

@@ -0,0 +1,88 @@
+module Restspec::Schema::Types
+  class SchemaIdType < BasicType
+    attr_accessor :schema_name
+
+    def initialize(options, options_when_name_is_present = {})
+      if options.is_a?(Symbol)
+        self.schema_name = options
+        super(options_when_name_is_present)
+      else
+        super(options)
+      end
+    end
+
+    def example_for(attribute)
+      return sample_item.id if sample_item.present?
+
+      if create_response.code == 201 && create_response.body.try(:id)
+        create_response.body.id
+      else
+        example_options.fetch(:hardcoded_fallback) {
+          raise "We couldn't fetch any information for this example"
+        }
+      end
+    end
+
+    def valid?(attribute, value)
+      return true unless perform_validation?
+      item_ids.any? { |item| item.id == value }
+    end
+
+    private
+
+    def find_endpoint(name)
+      Restspec::EndpointStore.get(name)
+    end
+
+    def sample_item
+      @sample_item ||= get_sample_item
+    end
+
+    def get_index_endpoint
+      if schema_name.present?
+        Restspec::EndpointStore.get_by_schema_and_name(schema_name, :index)
+      else
+        find_endpoint(example_options.fetch(:fetch_endpoint))
+      end
+    end
+
+    def get_sample_item
+      fetch_endpoint = get_index_endpoint
+      fetch_endpoint.execute.body.try(:sample)
+    end
+
+    def create_response
+      create_endpoint.execute(body: create_example)
+    end
+
+    def get_create_endpoint
+      if schema_name.present?
+        namespace = Restspec::Endpoints::Namespace.get_by_schema_name(schema_name)
+        namespace.get_endpoint(:create)
+      else
+        find_endpoint(example_options.fetch(:create_endpoint))
+      end
+    end
+
+    def create_endpoint
+      @create_endpoint ||= get_create_endpoint
+    end
+
+    def create_example
+      Restspec.example_for(create_schema_name)
+    end
+
+    def create_schema_name
+      example_options.fetch(:create_schema, create_endpoint.schema_name)
+    end
+
+    def perform_validation?
+      schema_options.fetch(:perform_validation, true)
+    end
+
+    def item_ids
+      fetch_endpoint = get_index_endpoint
+      fetch_endpoint.execute.body
+    end
+  end
+end

data/lib/restspec/schema/types/string_type.rb

@@ -0,0 +1,11 @@
+module Restspec::Schema::Types
+  class StringType < BasicType
+    def example_for(attribute)
+      Faker::Lorem.word
+    end
+
+    def valid?(attribute, value)
+      value.is_a?(String)
+    end
+  end
+end

data/lib/restspec/shortcuts.rb

@@ -0,0 +1,8 @@
+module Restspec
+  class << self
+    def example_for(schema_name, extensions = {})
+      schema = Restspec::SchemaStore.get(schema_name)
+      Schema::SchemaExample.new(schema, extensions).value
+    end
+  end
+end

data/lib/restspec/stores/endpoint_store.rb

@@ -0,0 +1,25 @@
+require 'delegate'
+
+module Restspec
+  module Stores
+    class EndpointStoreDelegator < SimpleDelegator
+      def store(endpoint)
+        self[endpoint.full_name] = endpoint
+      end
+
+      def get(endpoint_name)
+        self[endpoint_name]
+      end
+
+      def get_by_schema_and_name(schema_name, endpoint_name)
+        values.find do |endpoint|
+          endpoint.schema_name == schema_name && endpoint.name == endpoint_name
+        end
+      end
+    end
+
+    EndpointStore = EndpointStoreDelegator.new(Hash.new)
+  end
+
+  EndpointStore = Stores::EndpointStore
+end

data/lib/restspec/stores/namespace_store.rb

@@ -0,0 +1,20 @@
+require 'delegate'
+
+module Restspec
+  module Stores
+    class NamespaceStoreDelegator < SimpleDelegator
+      def store(namespace)
+        self << namespace
+      end
+
+      def get(namespace_name)
+        possible_names = [namespace_name.to_s, namespace_name.to_sym]
+        find { |ns| possible_names.include?(ns.name) }
+      end
+    end
+
+    NamespaceStore = NamespaceStoreDelegator.new(Array.new)
+  end
+
+  NamespaceStore = Stores::NamespaceStore
+end

data/lib/restspec/stores/schema_store.rb

@@ -0,0 +1,19 @@
+require 'delegate'
+
+module Restspec
+  module Stores
+    class SchemaStoreDelegator < SimpleDelegator
+      def store(schema)
+        self[schema.name] = schema
+      end
+
+      def get(schema_name)
+        self[schema_name]
+      end
+    end
+
+    SchemaStore = SchemaStoreDelegator.new(Hash.new)
+  end
+
+  SchemaStore = Stores::SchemaStore
+end

data/lib/restspec/values/status_code.rb

@@ -0,0 +1,13 @@
+module Restspec
+  module Values
+    class StatusCode < Struct.new(:number_or_symbol)
+      def value
+        if number_or_symbol.is_a?(Symbol)
+          Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(number_or_symbol)
+        else
+          number_or_symbol
+        end
+      end
+    end
+  end
+end

data/lib/restspec/values/super_hash.rb

@@ -0,0 +1,12 @@
+require 'hashie'
+
+module Restspec
+  module Values
+    class SuperHash < Hash
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::IndifferentAccess
+      include Hashie::Extensions::MergeInitializer
+    end
+  end
+end

data/lib/restspec/version.rb

@@ -0,0 +1,3 @@
+module Restspec
+  VERSION = "0.0.1"
+end

data/restspec.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "restspec"
+  spec.version       = Restspec::VERSION
+  spec.authors       = ["juliogarciag"]
+  spec.email         = ["julioggonz@gmail.com"]
+  spec.summary       = %q{RSpec macros, helpers and matchers to work with APIs}
+  spec.description   = %q{RSpec macros, helpers and matchers to work with APIs}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ['restspec']
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "guard", "~> 2.8"
+  spec.add_development_dependency "guard-rspec", "~> 4.3"
+  spec.add_development_dependency "rspec-nc", "~> 0.2"
+  spec.add_development_dependency "simplecov", "~> 0.9.1"
+  spec.add_dependency "activesupport", "~> 4.0"
+  spec.add_dependency "faker", "~> 1.4"
+  spec.add_dependency "hashie", "~> 3.3"
+  spec.add_dependency "rack", "~> 1.0"
+  spec.add_dependency "rspec", "~> 3.0"
+  spec.add_dependency "httparty", "~> 0.13"
+  spec.add_dependency "rspec-its", "~> 1.0"
+  spec.add_dependency "rspec-collection_matchers", "~> 1.0"
+  spec.add_dependency "thor", "~> 0.19"
+end

data/spec/restspec/endpoints/dsl_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe Restspec::Endpoints::DSL do
+  let(:dsl) { Restspec::Endpoints::DSL.new }
+
+  before do
+    Restspec::NamespaceStore.clear
+    Restspec::EndpointStore.clear
+  end
+
+  describe '#namespace' do
+    it 'creates a namespace' do
+      expect do
+        dsl.namespace(:monkey) { }
+      end.to change { Restspec::NamespaceStore.size }.by(1)
+    end
+
+    it 'creates a namespace with the given name as a string' do
+      dsl.namespace(:monkey) { }
+      expect(Restspec::NamespaceStore.first.name).to eq('monkey')
+    end
+
+    it 'creates a namespace with the given base_path' do
+      dsl.namespace(:monkey, base_path: '/monkey') { }
+      expect(Restspec::NamespaceStore.first.full_base_path).to eq('/monkey')
+    end
+
+    it 'yields a Restspec::Endpoints::NamespaceDSL attached to the namespace to the block' do
+      namespace_dsl = OpenStruct.new(call: true)
+
+      allow(namespace_dsl).to receive(:call).and_return(true)
+      allow(Restspec::Endpoints::NamespaceDSL).to receive(:new) do |namespace|
+        namespace_dsl.namespace = namespace
+        namespace_dsl
+      end
+
+      dsl.namespace(:monkey) do
+        self.call
+      end
+
+      expect(namespace_dsl).to have_received(:call)
+      expect(namespace_dsl.namespace).to eq(Restspec::NamespaceStore.first)
+    end
+  end
+
+  describe '#resource' do
+    it 'creates a namespace with the base_path equals to /:name' do
+      dsl.resource(:monkeys) { }
+      expect(Restspec::NamespaceStore.first.full_base_path).to eq('/monkeys')
+    end
+
+    it 'creates a namespace with the schema attached to some schema with the same name' do
+      dsl.resource(:monkeys) { }
+      expect(Restspec::NamespaceStore.first.schema_name).to eq(:monkey)
+    end
+  end
+
+  describe Restspec::Endpoints::NamespaceDSL do
+    let(:namespace) { Restspec::Endpoints::Namespace.new(:monkeys) }
+    let(:ns_dsl) { Restspec::Endpoints::NamespaceDSL.new(namespace) }
+
+    describe '#endpoint' do
+      it 'creates an endpoint for the namespace' do
+        expect do
+          ns_dsl.endpoint(:show) { }
+        end.to change { Restspec::EndpointStore.size }.by(1)
+      end
+
+      it 'creates an endpoint with the full name of the endpoint' do
+        ns_dsl.endpoint(:show) { }
+        expect(Restspec::EndpointStore.get("monkeys/show")).to be_present
+      end
+    end
+
+    describe 'HTTP_METHODS calls' do
+      Restspec::Endpoints::HTTP_METHODS.each do |http_method|
+        describe "##{http_method}" do
+          it "creates an endpoint with the method set to #{http_method} and the correct path" do
+            ns_dsl.send(http_method, :show, '/hola')
+            endpoint = Restspec::EndpointStore.get("monkeys/show")
+            expect(endpoint.method).to eq(http_method)
+            expect(endpoint.path).to eq('/hola')
+          end
+        end
+      end
+    end
+
+    describe '#schema' do
+      it 'sets the schema_name of the namespace' do
+        expect do
+          ns_dsl.schema :schema_name
+        end.to change { namespace.schema_name }.to(:schema_name)
+      end
+    end
+
+    describe '#all' do
+      it 'calls the same block in all the endpoints inside' do
+        ns_dsl.all do
+          schema :a_schema_name
+        end
+
+        ns_dsl.endpoint(:a) { }
+        ns_dsl.endpoint(:b) { }
+
+        endpoint_a = Restspec::EndpointStore.get('monkeys/a')
+        endpoint_b = Restspec::EndpointStore.get('monkeys/b')
+
+        expect(endpoint_a.schema_name).to eq(:a_schema_name)
+        expect(endpoint_b.schema_name).to eq(:a_schema_name)
+      end
+    end
+
+    describe '#url_param' do
+      it 'sets the url_params in each endpoint' do
+        ns_dsl.url_param(:param) { 'value' }
+
+        ns_dsl.endpoint(:a) { }
+        ns_dsl.endpoint(:b) { }
+
+        Restspec::EndpointStore.each do |_, endpoint|
+          expect(endpoint.url_params[:param]).to eq('value')
+        end
+      end
+    end
+
+    describe 'resource sub-methods' do
+      let(:namespace) do
+        dsl.resource(:monkeys) { }
+        Restspec::NamespaceStore.get(:monkeys)
+      end
+
+      shared_examples :anonymous_namespace_method do |method_name|
+        it 'does not adds itself to the NamespaceStore' do
+          expect do
+            ns_dsl.send(method_name) { }
+          end.to_not change { Restspec::EndpointStore.size }
+        end
+
+        it 'creates a namespace inside the parent namespace' do
+          expect do
+            ns_dsl.send(method_name) { }
+          end.to change { namespace.children_namespaces.size }.by(1)
+        end
+
+        it 'creates an anonymous namespace' do
+          ns_dsl.send(method_name) { }
+          expect(namespace.children_namespaces.first).to be_anonymous
+        end
+      end
+
+      describe '#member' do
+        it 'adds a namespace that attaches the namespace parent base_path and the /:id path to the endpoints inside' do
+          ns_dsl.member do
+            endpoint(:a) { }
+            endpoint(:b) { path '/home' }
+          end
+
+          expect(Restspec::EndpointStore.get("monkeys/a").full_path).to eq('/monkeys/:id')
+          expect(Restspec::EndpointStore.get("monkeys/b").full_path).to eq('/monkeys/:id/home')
+        end
+
+        it_behaves_like :anonymous_namespace_method, :member
+      end
+
+      describe '#collection' do
+        it 'adds a namespace that attaches the previous base_path to the current path' do
+          ns_dsl.collection do
+            endpoint(:a) { }
+            endpoint(:b) { path '/home' }
+          end
+
+          expect(Restspec::EndpointStore.get("monkeys/a").full_path).to eq('/monkeys')
+          expect(Restspec::EndpointStore.get("monkeys/b").full_path).to eq('/monkeys/home')
+        end
+
+        it_behaves_like :anonymous_namespace_method, :collection
+      end
+    end
+  end
+
+  describe Restspec::Endpoints::EndpointDSL do
+    let(:endpoint) { Restspec::Endpoints::Endpoint.new }
+    let(:endpoint_dsl) { Restspec::Endpoints::EndpointDSL.new(endpoint) }
+
+    describe '#method' do
+      it 'sets the method of the endpoint' do
+        expect { endpoint_dsl.method :get }.to change { endpoint.method }.to(:get)
+      end
+    end
+
+    describe '#path' do
+      it 'sets the path of the endpoint' do
+        expect {
+          endpoint_dsl.path '/hola'
+        }.to change { endpoint.full_path }.from(nil).to('/hola')
+      end
+    end
+
+    describe '#schema' do
+      it 'sets the schema_name' do
+        expect {
+          endpoint_dsl.schema :monkey
+        }.to change { endpoint.schema_name }.from(nil).to(:monkey)
+      end
+
+      it 'sets the schema_name with schema_extensions' do
+        extensions = { a: 1, b: 2, c: 3 }
+
+        expect {
+          endpoint_dsl.schema :monkey, extensions
+        }.to change { endpoint.schema_extensions }.from(nil).to(extensions)
+      end
+    end
+
+    describe '#headers' do
+      it 'changes the headers of the endpoint' do
+        expect do
+          endpoint_dsl.headers['hola'] = 'mundo'
+        end.to change { endpoint.headers['hola'] }.from(nil).to('mundo')
+      end
+    end
+
+    describe '#url_param' do
+      context 'with a block returning a raw value' do
+        it 'adds the raw param to the endpoint' do
+          endpoint_dsl.url_param(:param) { 'param' }
+          expect(endpoint.url_params).to have_key(:param)
+          expect(endpoint.url_params[:param]).to eq('param')
+        end
+      end
+
+      context 'with a block returning a schema type' do
+        let(:type) { Restspec::Schema::Types::StringType.new }
+
+        before do
+          allow(type).to receive(:example_for).and_return('')
+        end
+
+        it 'executes example_for in the type' do
+          type = self.type
+
+          endpoint_dsl.url_param(:param) { type }
+          found_param = endpoint.url_params[:param]
+
+          expect(type).to have_received(:example_for)
+          expect(found_param).to eq('')
+        end
+
+        context 'when the endpoint has a schema' do
+          let(:schema) { double(attributes: { param: 1 }) }
+
+          before do
+            allow(endpoint).to receive(:schema).and_return(schema)
+          end
+
+          it 'calls the example_for with the attribute from the schema' do
+            type = self.type
+
+            endpoint_dsl.url_param(:param) { type }
+            found_param = endpoint.url_params[:param]
+
+            expect(type).to have_received(:example_for).with(1)
+          end
+        end
+      end
+    end
+  end
+end
+