restspec 0.0.1

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

@@ -0,0 +1,17 @@
+require 'rack'
+
+RSpec::Matchers.define :have_status do |status_code|
+  match do |response|
+    response.code == Restspec::Values::StatusCode.new(status_code).value
+  end
+
+  failure_message do |response|
+    status_code = Restspec::Values::StatusCode.new(expected).value
+    "expected #{response} to have status code: #{status_code} but it was #{response.code}"
+  end
+
+  failure_message_when_negated do |actual|
+    status_code = Restspec::Values::StatusCode.new(expected).value
+    "expected #{response} to don't have status code: #{status_code} but it was #{response.code}"
+  end
+end

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

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :include_where do |condition|
+  match do |array|
+    raise "You can use :include_where with an array response" unless array.is_a?(Array)
+    array.any? { |item| condition.call(item) }
+  end
+
+  failure_message do |array|
+    "expected array to include something according to the block #{condition}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected array to not include something according to the block #{condition}"
+  end
+end

data/lib/restspec/rspec/shared_examples.rb

@@ -0,0 +1,12 @@
+RSpec.shared_examples :successful_schema_fetch do
+  it { should have_status(:ok) }
+  it { should be_like_schema }
+end
+
+RSpec.shared_examples :a_not_found_test do
+  test 'with a unexisting id' do
+    url_params(id: 0)
+
+    it { should have_status(:not_found) }
+  end
+end

data/lib/restspec/schema/attribute.rb

@@ -0,0 +1,31 @@
+module Restspec
+  module Schema
+    class Attribute
+      attr_reader :name, :type
+
+      def initialize(name, type, options = {})
+        self.name = name
+        self.type = type
+        self.example_override = options.fetch(:example, nil)
+        self.allowed_abilities = options.fetch(:for, [:checks, :examples])
+      end
+
+      def example
+        @example ||= example_override
+      end
+
+      def can_generate_examples?
+        allowed_abilities.include?(:examples)
+      end
+
+      def can_be_checked?
+        allowed_abilities.include?(:checks)
+      end
+
+      private
+
+      attr_writer :name, :type
+      attr_accessor :example_override, :allowed_abilities
+    end
+  end
+end

data/lib/restspec/schema/attribute_example.rb

@@ -0,0 +1,21 @@
+require 'faker'
+
+module Restspec
+  module Schema
+    class AttributeExample < Struct.new(:attribute)
+      def value
+        if attribute.example.present?
+          attribute.example.try(:call) || attribute.example
+        else
+          type.example_for(attribute)
+        end
+      end
+
+      private
+
+      def type
+        attribute.type
+      end
+    end
+  end
+end

data/lib/restspec/schema/checker.rb

@@ -0,0 +1,73 @@
+module Restspec
+  module Schema
+    class Checker < Struct.new(:schema)
+      def check_array!(array)
+        array.each { |item| check!(item) }
+      end
+
+      def check!(object)
+        raise NoObjectError.new(object) unless object.is_a?(Hash)
+
+        schema.attributes.each do |_, attribute|
+          if attribute.can_be_checked?
+            checker = ObjectChecker.new(object, attribute)
+
+            raise NoAttributeError.new(object, attribute) if checker.missed_key?
+            raise DifferentTypeError.new(object, attribute) if checker.wrong_type?
+          end
+        end
+      end
+
+      private
+
+      class ObjectChecker < Struct.new(:object, :attribute)
+        def missed_key?
+          !object.has_key?(attribute.name)
+        end
+
+        def wrong_type?
+          !attribute.type.totally_valid?(attribute, object.fetch(attribute.name))
+        end
+      end
+
+      class NoAttributeError < StandardError
+        attr_accessor :object, :attribute
+
+        def initialize(object, attribute)
+          self.object = object
+          self.attribute = attribute
+        end
+
+        def to_s
+          "The object #{object} does not have the attribute #{attribute.name}"
+        end
+      end
+
+      class DifferentTypeError < StandardError
+        attr_accessor :object, :attribute, :value
+
+        def initialize(object, attribute)
+          self.object = object
+          self.attribute = attribute
+          self.value = object.fetch(attribute.name)
+        end
+
+        def to_s
+          "The property #{attribute.name} of #{object} should be of type #{attribute.type} but it was of type #{value.class}"
+        end
+      end
+
+      class NoObjectError < StandardError
+        attr_accessor :object
+
+        def initialize(object)
+          self.object = object
+        end
+
+        def to_s
+          "The object #{object}:#{object.class} is not a hash. It doesn't have attributes to be checked"
+        end
+      end
+    end
+  end
+end

data/lib/restspec/schema/dsl.rb

@@ -0,0 +1,36 @@
+module Restspec
+  module Schema
+    class DSL
+      attr_reader :schemas
+
+      def schema(name, &definition)
+        dsl = SingleSchemaDSL.new(name)
+        dsl.instance_eval(&definition)
+        Restspec::SchemaStore.store(dsl.schema)
+      end
+    end
+
+    class SingleSchemaDSL
+      attr_reader :schema
+
+      def initialize(name)
+        self.schema = Schema.new(name)
+      end
+
+      def attribute(name, type, options = {})
+        new_attribute = Attribute.new(name, type, options)
+        schema.attributes[name.to_s] = new_attribute
+      end
+
+      Types::ALL.each do |type_name, type_class|
+        define_method(type_name) do |options = {}|
+          type_class.new(options)
+        end
+      end
+
+      private
+
+      attr_writer :schema
+    end
+  end
+end

data/lib/restspec/schema/schema.rb

@@ -0,0 +1,21 @@
+module Restspec
+  module Schema
+    class Schema
+      attr_reader :name, :attributes
+
+      def initialize(name)
+        self.name = name
+        self.attributes = {}
+      end
+
+      def extend_with(without: [])
+        without.each { |attribute_name| attributes.delete(attribute_name.to_s) }
+        self
+      end
+
+      private
+
+      attr_writer :name, :attributes
+    end
+  end
+end

data/lib/restspec/schema/schema_example.rb

@@ -0,0 +1,28 @@
+module Restspec
+  module Schema
+    class SchemaExample
+      attr_accessor :schema, :extensions
+
+      def initialize(schema, extensions = {})
+        self.schema = schema
+        self.extensions = extensions
+      end
+
+      def value
+        attributes.inject({}) do |sample, (_, attribute)|
+          if attribute.can_generate_examples?
+            sample.merge(attribute.name => AttributeExample.new(attribute).value)
+          else
+            sample
+          end
+        end.merge(extensions)
+      end
+
+      private
+
+      def attributes
+        schema.attributes
+      end
+    end
+  end
+end

data/lib/restspec/schema/types.rb

@@ -0,0 +1,35 @@
+module Restspec
+  module Schema
+    module Types
+    end
+  end
+end
+
+require_relative './types/basic_type'
+require_relative './types/string_type'
+require_relative './types/integer_type'
+require_relative './types/decimal_type'
+require_relative './types/boolean_type'
+require_relative './types/decimal_string_type'
+require_relative './types/schema_id_type'
+require_relative './types/array_type'
+require_relative './types/one_of_type'
+require_relative './types/hash_type'
+require_relative './types/null_type'
+require_relative './types/embedded_schema_type'
+
+module Restspec::Schema::Types
+  ALL = {
+    string: StringType,
+    integer: IntegerType,
+    decimal: DecimalType,
+    boolean: BooleanType,
+    decimal_string: DecimalStringType,
+    schema_id: SchemaIdType,
+    array: ArrayType,
+    one_of: OneOfType,
+    hash: HashType,
+    null: NullType,
+    embedded_schema: EmbeddedSchemaType
+  }
+end

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

@@ -0,0 +1,34 @@
+module Restspec::Schema::Types
+  class ArrayType < BasicType
+    def example_for(attribute)
+      length_only_works_with_parameterized_types!
+
+      example_length.times.map do
+        parameterized_type.example_for(attribute)
+      end
+    end
+
+    def valid?(attribute, value)
+      is_array = value.is_a?(Array)
+      if parameterized_type
+        is_array && value.all? do |item|
+          parameterized_type.totally_valid?(attribute, item)
+        end
+      else
+        is_array
+      end
+    end
+
+    private
+
+    def example_length
+      example_options.fetch(:length, 0)
+    end
+
+    def length_only_works_with_parameterized_types!
+      if example_options.has_key?(:length) && !parameterized_type
+        raise "To use the :length option you need to have a parameterized_type or we can't generate the array"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+class Restspec::Schema::Types::BasicType
+  def initialize(options = {})
+    self.options = options
+  end
+
+  def |(other_type)
+    self.disjuction = other_type
+    self
+  end
+
+  def of(other_type)
+    self.parameterized_type = other_type
+    self
+  end
+
+  def totally_valid?(attribute, value)
+    if disjuction.present?
+      valid?(attribute, value) || disjuction.valid?(attribute, value)
+    else
+      valid?(attribute, value)
+    end
+  end
+
+  private
+
+  attr_accessor :options, :disjuction, :parameterized_type
+
+  def example_options
+    options.fetch(:example_options, options)
+  end
+
+  def schema_options
+    options.fetch(:schema_options, options)
+  end
+end

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

@@ -0,0 +1,11 @@
+module Restspec::Schema::Types
+  class BooleanType < BasicType
+    def example_for(attribute)
+      [true, false].sample
+    end
+
+    def valid?(attribute, value)
+      [true, false].include?(value)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Restspec::Schema::Types
+  class DecimalStringType < DecimalType
+    def example_for(attribute)
+      super(attribute).to_s
+    end
+
+    def valid?(attribute, value)
+      return false unless value.is_a?(String)
+      decimal_regex.match(value).present?
+    end
+
+    private
+
+    def decimal_regex
+      @decimal_regex ||= build_regex
+    end
+
+    def build_regex
+      integer_part_limit = to_regexp_limit(schema_options.fetch(:integer_part, nil))
+      decimal_part_limit = to_regexp_limit(schema_options.fetch(:decimal_part, nil))
+      /^\d#{integer_part_limit}([.,]\d#{decimal_part_limit})?$/
+    end
+
+    def to_regexp_limit(limit, default = '+')
+      if limit.nil?
+        default
+      else
+        "{#{limit}}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Restspec::Schema::Types
+  class DecimalType < BasicType
+    def example_for(attribute)
+      integer_part = example_options.fetch(:integer_part, 2)
+      decimal_part = example_options.fetch(:decimal_part, 2)
+
+      Faker::Number.decimal(integer_part, decimal_part)
+    end
+
+    def valid?(attribute, value)
+      value.is_a?(Numeric)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Restspec::Schema::Types
+  class EmbeddedSchemaType < 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)
+      Restspec::Schema::SchemaExample.new(schema).value
+    end
+
+    def valid?(attribute, value)
+      Restspec::Schema::Checker.new(schema).check!(value)
+    end
+
+    private
+
+    def schema
+      @schema ||= Restspec::SchemaStore.get(schema_name)
+    end
+  end
+end