restspec 0.0.4 → 0.1

data/spec/restspec/endpoints/dsl_spec.rb

@@ -17,12 +17,12 @@ describe Restspec::Endpoints::DSL do
 
     it 'creates a namespace with the given name as a string' do
       dsl.namespace(:monkey) { }
-      expect(Restspec::NamespaceStore.first.name).to eq('monkey')
+      expect(Restspec::NamespaceStore.get(:monkey).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')
+      expect(Restspec::NamespaceStore.get(:monkey).full_base_path).to eq('/monkey')
     end
 
     it 'yields a Restspec::Endpoints::NamespaceDSL attached to the namespace to the block' do
@@ -39,19 +39,24 @@ describe Restspec::Endpoints::DSL do
       end
 
       expect(namespace_dsl).to have_received(:call)
-      expect(namespace_dsl.namespace).to eq(Restspec::NamespaceStore.first)
+      expect(namespace_dsl.namespace).to eq(Restspec::NamespaceStore.get(:monkey))
     end
   end
 
   describe '#resource' do
+    before do
+      schema = Restspec::Schema::Schema.new(:monkey)
+      Restspec::SchemaStore.store(schema)
+    end
+
     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')
+      expect(Restspec::NamespaceStore.get(:monkeys).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)
+      expect(Restspec::NamespaceStore.get(:monkeys).schema_for(:response).name).to eq(:monkey)
     end
   end
 
@@ -86,14 +91,22 @@ describe Restspec::Endpoints::DSL do
     end
 
     describe '#schema' do
+      before do
+        Restspec::SchemaStore.store(Restspec::Schema::Schema.new(:schema_name))
+      end
+
       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.to change { namespace.schema_for(:response).try(:name) }.to(:schema_name)
       end
     end
 
     describe '#all' do
+      before do
+        Restspec::SchemaStore.store(Restspec::Schema::Schema.new(:a_schema_name))
+      end
+
       it 'calls the same block in all the endpoints inside' do
         ns_dsl.all do
           schema :a_schema_name
@@ -105,8 +118,8 @@ describe Restspec::Endpoints::DSL do
         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)
+        expect(endpoint_a.schema_for(:response).name).to eq(:a_schema_name)
+        expect(endpoint_a.schema_for(:response).name).to eq(:a_schema_name)
       end
     end
 
@@ -196,19 +209,19 @@ describe Restspec::Endpoints::DSL do
       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)
+    describe '#no_schema' do
+      it 'removes the schema' do
+        endpoint_dsl.schema :monkey
+        endpoint_dsl.no_schema
+        expect(endpoint.all_schemas).to eq([])
       end
+    end
 
-      it 'sets the schema_name with schema_extensions' do
-        extensions = { a: 1, b: 2, c: 3 }
-
+    describe '#schema' do
+      it 'sets the schema for response' do
         expect {
-          endpoint_dsl.schema :monkey, extensions
-        }.to change { endpoint.schema_extensions }.from(nil).to(extensions)
+          endpoint_dsl.schema :monkey
+        }.to change { endpoint.schema_for(:response).try(:name) }.from(nil).to(:monkey)
       end
     end
 
@@ -250,7 +263,7 @@ describe Restspec::Endpoints::DSL do
           let(:schema) { double(attributes: { param: 1 }) }
 
           before do
-            allow(endpoint).to receive(:schema).and_return(schema)
+            allow(endpoint).to receive(:schema_for).and_return(schema)
           end
 
           it 'calls the example_for with the attribute from the schema' do

data/spec/restspec/endpoints/endpoint_spec.rb

@@ -6,6 +6,25 @@ describe Endpoint do
   let(:endpoint) { Endpoint.new(:endpoint) }
   subject { endpoint }
 
+  describe '#payload' do
+    let(:schema) do
+      dsl = Restspec::Schema::SingleSchemaDSL.new(:product, {})
+      dsl.instance_eval do
+        attribute :title, string, example: 'monkey'
+      end
+      dsl.schema
+    end
+
+    before do
+      Restspec::SchemaStore.store(schema)
+      endpoint.add_schema(schema.name, :for => [:payload])
+    end
+
+    it 'is an example for the schema' do
+      expect(endpoint.payload).to eq(title: 'monkey')
+    end
+  end
+
   describe '#full_name' do
     context 'standalone' do
       its(:full_name) { should eq('endpoint') }
@@ -66,48 +85,6 @@ describe Endpoint do
     end
   end
 
-  describe '#schema_name' do
-    context 'stadalone' do
-      before { endpoint.schema_name = :schema_name }
-      its(:schema_name) { should eq(:schema_name) }
-    end
-
-    context 'inside a namespace' do
-      let(:namespace) do
-        Namespace.new(:namespace).tap do |ns|
-          ns.schema_name = :ns_schema_name
-        end
-      end
-
-      before { endpoint.namespace = namespace }
-
-      context 'without a single schema name' do
-        its(:schema_name) { should eq(:ns_schema_name) }
-      end
-
-      context 'with a single schema name' do
-        before { endpoint.schema_name = :single_schema_name }
-        its(:schema_name) { should eq(:single_schema_name) }
-      end
-    end
-  end
-
-  describe '#schema' do
-    let(:schema) { double }
-
-    before do
-      endpoint.schema_name = :single_schema_name
-      allow(Restspec::SchemaStore).to receive(:get).and_return(schema)
-      allow(schema).to receive(:extend_with) { schema }
-    end
-
-    it 'tells the Restspec::Schema::Finder to find a schema' do
-      found_schema = endpoint.schema
-      expect(Restspec::SchemaStore).to have_received(:get).with(:single_schema_name)
-      expect(found_schema).to eq(schema)
-    end
-  end
-
   describe '#url_params' do
     before do
       endpoint.add_url_param_block(:mono) { 'mono' }
@@ -130,8 +107,8 @@ describe Endpoint do
     end
 
     context 'inside an anonymous namespace (a member or collection block)' do
-      let(:member_namespace) { Namespace.create }
       let(:top_level_namespace) { Namespace.create('top_level') }
+      let(:member_namespace) { top_level_namespace.add_anonymous_children_namespace }
 
       before do
         top_level_namespace.base_path = '/monkeys'

data/spec/restspec/endpoints/namespace_spec.rb

@@ -10,13 +10,6 @@ describe Namespace do
       namespace = Namespace.create(:name)
       expect(Restspec::NamespaceStore.get(:name)).to eq(namespace)
     end
-
-    context 'without arguments' do
-      it 'creates an anonymous namespace' do
-        namespace = Namespace.create
-        expect(namespace).to be_anonymous
-      end
-    end
   end
 
   describe '#add_anonymous_children_namespace' do

data/spec/restspec/endpoints/request_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+include Restspec::Endpoints
+
+describe Request do
+  let(:request) do
+    Request.new(:get, '/url', {'header' => 'header'}, {'payload' => 'payload'})
+  end
+
+  it 'is a bag for request data' do
+    expect(request.method).to eq(:get)
+    expect(request.url).to eq('/url')
+    expect(request.headers).to eq({'header' => 'header'})
+    expect(request.payload).to eq({'payload' => 'payload'})
+  end
+
+  describe '#endpoint=' do
+    let(:endpoint) { double }
+
+    it 'injects an endpoint' do
+      request.endpoint = endpoint
+      expect(request.endpoint).to eq(endpoint)
+    end
+  end
+
+  describe '#raw_payload' do
+    it 'is the raw payload to send through the wire json encoded' do
+      request.payload = { 'hola' => 'mundo' }
+      expect(JSON.parse(request.raw_payload)).to eq(request.payload)
+    end
+  end
+end
+

data/spec/restspec/schema/attribute_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+include Restspec::Schema
+
+describe Attribute do
+  let(:type) { double }
+
+  describe '#example' do
+    let(:example) { 'example' }
+    let(:attribute) { Attribute.new(:name, type, example: example) }
+
+    it 'returns the example option' do
+      expect(attribute.example).to eq(example)
+    end
+  end
+
+  describe '#can_generate_examples?' do
+    subject { attribute.can_generate_examples? }
+
+    context 'without the option' do
+      let(:attribute) { Attribute.new(:name, type, example: 'example', :for => []) }
+      it { should eq(false) }
+    end
+
+    context 'with the option' do
+      let(:attribute) { Attribute.new(:name, type, example: 'example', :for => [:examples]) }
+      it { should eq(true) }
+    end
+  end
+
+  describe '#can_be_checked?' do
+    subject { attribute.can_be_checked? }
+
+    context 'without the option' do
+      let(:attribute) { Attribute.new(:name, type, :for => []) }
+      it { should eq(false) }
+    end
+
+    context 'with the option' do
+      let(:attribute) { Attribute.new(:name, type, :for => [:checks]) }
+      it { should eq(true) }
+    end
+  end
+end

data/spec/restspec/schema/checker_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+include Restspec::Schema
+
+describe Checker do
+  let(:schema) do
+    Schema.new(:product).tap do |schema|
+      schema.attributes[:name] = Attribute.new(:name, Types::StringType.new)
+    end
+  end
+
+  let(:checker) { Checker.new(schema) }
+
+  describe '#check!' do
+    context 'when no object is sent' do
+      it 'raises a Checker::NoObjectError' do
+        expect do
+          checker.check!(nil)
+        end.to raise_error(Checker::NoObjectError, /Nil/)
+      end
+    end
+
+    context 'when no attribute is present' do
+      it 'raises a Checker::NoAttributeError' do
+        expect do
+          checker.check!(age: 10)
+        end.to raise_error(Checker::NoAttributeError, /name/)
+      end
+    end
+
+    context 'when the attribute is not valid' do
+      it 'raises a Checker::InvalidationError' do
+        expect do
+          checker.check!(name: 10)
+        end.to raise_error(Checker::InvalidationError, /string/)
+      end
+    end
+
+    context 'when the attribute is present and valid' do
+      it 'does not raises any error' do
+        expect do
+          checker.check!(name: 'John')
+        end.to_not raise_error
+      end
+    end
+  end
+
+  describe '#check_array!' do
+    let(:array) { [1, 2, 3] }
+
+    it 'calls #check! with every item of the array' do
+      allow(checker).to receive(:check!).and_return(true)
+      checker.check_array!(array)
+      expect(checker).to have_received(:check!).exactly(3).times
+    end
+  end
+end

data/spec/restspec/schema/dsl_spec.rb

@@ -78,7 +78,7 @@ describe SingleSchemaDSL do
 
   describe '#include_attributes' do
     let(:main_dsl) { DSL.new }
-    let(:schema_dsl) { SingleSchemaDSL.new(:name, main_dsl.mixins) }
+    let(:schema_dsl) { SingleSchemaDSL.new(:name, main_dsl.send(:mixins)) }
 
     before do
       main_dsl.mixin :test_mixin do

data/spec/restspec/schema/schema_spec.rb

@@ -8,4 +8,19 @@ describe Restspec::Schema::Schema do
     expect(person_schema.attributes).to eq({})
     expect(person_schema.name).to eq(:person)
   end
+
+  describe '#extend_with' do
+    let(:schema) { Schema.new(:person) }
+
+    before do
+      schema.attributes['attribute'] = 'Attribute'
+    end
+
+    context 'using :without' do
+      it 'removes an attribute' do
+        schema.extend_with(without: ['attribute'])
+        expect(schema.attributes).to_not have_key('attribute')
+      end
+    end
+  end
 end

data/spec/restspec/schema/types/basic_type_spec.rb

@@ -13,7 +13,7 @@ describe BasicType do
   let(:attribute) { double }
   let(:value) { double }
 
-  describe '|' do
+  describe '#|' do
     let(:other_type) { subclass.new }
 
     before do
@@ -38,7 +38,7 @@ describe BasicType do
     end
   end
 
-  describe 'of' do
+  describe '#of' do
     let(:other_type) { subclass.new }
 
     let(:subclass) do

data/spec/restspec/schema/types/decimal_string_type_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe DecimalStringType do
+  let(:options) { {} }
+  let(:type) { DecimalStringType.new options }
+
+  describe '#example_for' do
+    it 'generates a random number wrapped in a string' do
+      10.times do
+        sample = type.example_for(double)
+        expect(sample).to respond_to(:to_f)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'without integer_part or decimal_part options' do
+      it 'will validate against any decimal string' do
+        expect(type.totally_valid?(double, '0.1001019')).to eq(true)
+        expect(type.totally_valid?(double, '9992329323.9')).to eq(true)
+        expect(type.totally_valid?(double, '9992329323.0')).to eq(true)
+        expect(type.totally_valid?(double, '9992329323')).to eq(true)
+        expect(type.totally_valid?(double, 'mono')).to eq(false)
+        expect(type.totally_valid?(double, '')).to eq(false)
+        expect(type.totally_valid?(double, 199.99)).to eq(false)
+      end
+    end
+
+    context 'with integer part and decimal part options' do
+      context 'with 2,2' do
+        let(:options) { { schema_options: { integer_part: 2, decimal_part: 2 } } }
+
+        it 'will validate only against strings with two integer parts and two decimal parts' do
+          expect(type.totally_valid?(double, '2.22')).to eq(true)
+          expect(type.totally_valid?(double, '22.22')).to eq(true)
+          expect(type.totally_valid?(double, '222.22')).to eq(false)
+          expect(type.totally_valid?(double, '22.221')).to eq(false)
+        end
+      end
+
+      context 'with 2,0' do
+        let(:options) { { schema_options: { integer_part: 2, decimal_part: 0 } } }
+
+        it 'will validate only against strings with two integer parts and 0 decimal parts' do
+          expect(type.totally_valid?(double, '2')).to eq(true)
+          expect(type.totally_valid?(double, '22')).to eq(true)
+          expect(type.totally_valid?(double, '222.22')).to eq(false)
+          expect(type.totally_valid?(double, '22.2')).to eq(false)
+        end
+      end
+    end
+  end
+end
+

data/spec/restspec/schema/types/decimal_type_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe DecimalType do
+  let(:options) { {} }
+  let(:type) { DecimalType.new(options) }
+
+  describe '#example_for' do
+    it 'generates numbers' do
+      10.times do
+        expect(type.example_for(double)).to be_kind_of(Numeric)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'only validates numbers' do
+      expect(type.totally_valid?(double, 100)).to eq(true)
+      expect(type.totally_valid?(double, '100')).to eq(false)
+      expect(type.totally_valid?(double, 'mono')).to eq(false)
+      expect(type.totally_valid?(double, nil)).to eq(false)
+    end
+  end
+end

data/spec/restspec/schema/types/embedded_schema_type_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe EmbeddedSchemaType do
+  let(:type) { EmbeddedSchemaType.new(:category) }
+
+  before do
+    Restspec::Schema::DSL.new.instance_eval do
+      schema :category do
+        attribute :name, string
+        attribute :description, string
+      end
+    end
+  end
+
+  describe '#example_for' do
+    it 'is a example of the embedded schema' do
+      sample = type.example_for(double)
+      expect(sample[:name]).to be_a_kind_of(String)
+    end
+  end
+
+  describe '#valid?' do
+    it 'is valid if this works with the embedded schema' do
+      expect(type.totally_valid?(double, name: 'Name', description: 'Desc')).to eq(true)
+      expect(type.totally_valid?(double, name: 'Name')).to eq(false)
+      expect(type.totally_valid?(double, age: 10)).to eq(false)
+      expect(type.totally_valid?(double, name: 'Name', description: nil)).to eq(false)
+    end
+  end
+end

data/spec/restspec/schema/types/hash_type_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe HashType do
+  let(:options) { {} }
+  let(:type) { HashType.new(options) }
+
+  describe '#example_for' do
+    it 'returns an empty hash' do
+      expect(type.example_for(double)).to eq({})
+    end
+  end
+
+  describe '#valid?' do
+    it 'validates if it is a hash' do
+      expect(type.totally_valid?(double, {a: 1})).to eq(true)
+      expect(type.totally_valid?(double, '{a: 1}')).to eq(false)
+    end
+
+    context 'with some specified keys' do
+      let(:options) { { schema_options: { keys: ['name', 'age'] } } }
+
+      it 'validates if the keys are present' do
+        expect(type.totally_valid?(double, { 'name' => 'name', 'age' => 19 })).to eq(true)
+        expect(type.totally_valid?(double, { 'name' => 'name', 'number' => 19 })).to eq(false)
+      end
+    end
+
+    context 'with a specified value_type' do
+      let(:options) { { schema_options: { value_type: StringType.new } } }
+
+      it 'validates that the values are of that type' do
+        expect(type.totally_valid?(double, { 'a' => '1', 'b' => '2' })).to eq(true)
+        expect(type.totally_valid?(double, { 'a' => '1', 'b' => 2 })).to eq(false)
+      end
+    end
+  end
+end

data/spec/restspec/schema/types/integer_type_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe IntegerType do
+  let(:type) { IntegerType.new }
+  let(:attribute) { double }
+
+  describe '#example_for' do
+    it 'returns a number' do
+      10.times do
+        expect(type.example_for(attribute)).to be_a_kind_of(Fixnum)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    it 'only validates integer values' do
+      expect(type.valid?(attribute, 1)).to eq(true)
+      expect(type.valid?(attribute, -10)).to eq(true)
+      expect(type.valid?(attribute, -10.5)).to eq(false)
+      expect(type.valid?(attribute, '10.5')).to eq(false)
+      expect(type.valid?(attribute, '10')).to eq(false)
+      expect(type.valid?(attribute, 'no')).to eq(false)
+      expect(type.valid?(attribute, nil)).to eq(false)
+    end
+  end
+end

data/spec/restspec/schema/types/one_of_type_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+include Restspec::Schema::Types
+
+describe OneOfType do
+  let(:type) { OneOfType.new(elements: [1, 2, 3]) }
+
+  describe '#example_for' do
+    it 'returns one example of the elements array' do
+      expect([1, 2, 3]).to include(type.example_for(double))
+    end
+  end
+
+  describe '#valid' do
+    it 'checks if the value is one of the elements array' do
+      expect(type.totally_valid?(double, 1)).to eq(true)
+      expect(type.totally_valid?(double, nil)).to eq(false)
+      expect(type.totally_valid?(double, '1')).to eq(false)
+    end
+  end
+end

data/spec/restspec/stores/endpoint_store_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+include Restspec::Stores
+
+describe "EndpointStore" do
+  let(:endpoint) { OpenStruct.new(:full_name => :name) }
+
+  before do
+    EndpointStore.clear
+  end
+
+  describe '#store' do
+    it 'stores the endpoint in a key hash called name' do
+      EndpointStore.store(endpoint)
+      expect(EndpointStore.get(:name)).to eq(endpoint)
+    end
+  end
+
+  describe '#get_by_schema_name_and_role' do
+    before do
+      Restspec::SchemaStore.store(Restspec::Schema::Schema.new(:schema_name_1))
+      Restspec::SchemaStore.store(Restspec::Schema::Schema.new(:schema_name_2))
+    end
+
+    let(:endpoint_1) do
+      Restspec::Endpoints::Endpoint.new(:name_1).tap do |endpoint|
+        endpoint.add_schema :schema_name_1, :for => [:response]
+      end
+    end
+
+    let(:endpoint_2) do
+      Restspec::Endpoints::Endpoint.new(:name_2).tap do |endpoint|
+        endpoint.add_schema :schema_name_2, :for => [:response]
+      end
+    end
+
+    before do
+      EndpointStore.store(endpoint_1)
+      EndpointStore.store(endpoint_2)
+    end
+
+    context 'without something with the same schema' do
+      let(:found_endpoint) do
+        EndpointStore.get_by_schema_name_and_role(:schema_name_1, :name_2, :response)
+      end
+
+      it 'is nil' do
+        expect(found_endpoint).to be_nil
+      end
+    end
+
+    context 'with something with the same schema and name' do
+      let(:found_endpoint) do
+        EndpointStore.get_by_schema_name_and_role(:schema_name_1, :name_1, :response)
+      end
+
+      it 'is the correct endpoint' do
+        expect(found_endpoint).to eq(endpoint_1)
+      end
+    end
+  end
+end