restspec 0.0.1

data/spec/restspec/endpoints/endpoint_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+include Restspec::Endpoints
+
+describe Endpoint do
+  let(:endpoint) { Endpoint.new(:endpoint) }
+  subject { endpoint }
+
+  describe '#full_name' do
+    context 'standalone' do
+      its(:full_name) { should eq('endpoint') }
+    end
+
+    context 'inside a namespace' do
+      before { endpoint.namespace = Namespace.new(:namespace) }
+      its(:full_name) { should eq('namespace/endpoint') }
+    end
+  end
+
+  describe '#execute_once' do
+    before do
+      allow(endpoint).to receive(:execute).and_return(true)
+    end
+
+    let(:body) { double }
+    let(:url_params) { double }
+    let(:query_params) { double }
+
+    it 'just calls execute once' do
+      4.times { endpoint.execute_once }
+      expect(endpoint).to have_received(:execute).once
+    end
+
+    it 'pass body, url_params and query_params to execute' do
+      endpoint.execute_once(body: body, url_params: url_params, query_params: query_params)
+      expect(endpoint).to have_received(:execute).with(
+        body: body, url_params: url_params, query_params: query_params
+      )
+    end
+
+    it 'executes :before param before executing' do
+      before_lambda = ->{ }
+      allow(before_lambda).to receive(:call)
+      endpoint.execute_once(before: before_lambda)
+
+      expect(before_lambda).to have_received(:call).ordered
+      expect(endpoint).to have_received(:execute).ordered
+    end
+  end
+
+  describe '#execute' do
+    let(:request) { OpenStruct.new }
+    let(:response) { OpenStruct.new }
+
+    before do
+      endpoint.method = :get
+      endpoint.path = '/home'
+
+      allow(Request).to receive(:new).and_return(request)
+      allow(Network).to receive(:request).and_return(response)
+    end
+
+    it 'tells the Network to request with a Request object containing everything' do
+      endpoint.execute
+      expect(Request).to have_received(:new).with(:get, '/home', {}, {})
+    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' }
+      endpoint.add_url_param_block(:xyz) { 'xyz' }
+    end
+
+    it 'is the list of execute url param blocks in a hash with string keys' do
+      expect(endpoint.url_params).to eq({
+        'mono' => 'mono',
+        'xyz' => 'xyz'
+      })
+    end
+  end
+
+  describe '#full_path' do
+    before { endpoint.path = '/full_path' }
+
+    context 'standalone' do
+      its(:full_path) { should eq('/full_path') }
+    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') }
+
+      before do
+        top_level_namespace.base_path = '/monkeys'
+        member_namespace.base_path = '/:id'
+        member_namespace.parent_namespace = top_level_namespace
+        endpoint.namespace = member_namespace
+      end
+
+      its(:full_path) { should eq('/monkeys/:id/full_path') }
+    end
+  end
+end

data/spec/restspec/endpoints/namespace_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+include Restspec::Endpoints
+
+describe Namespace do
+  let(:namespace) { Namespace.new(:namespace) }
+
+  describe '.create (and #anonymous?)' do
+    it 'stores the namespace in Restspec::NamespaceStore' 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
+    it 'adds one object to #children_namespaces' do
+      expect { namespace.add_anonymous_children_namespace }.to change {
+        namespace.children_namespaces.size
+      }.by(1)
+    end
+  end
+
+  describe '#add_endpoint' do
+    let(:endpoint) { OpenStruct.new }
+
+    it 'adds the endpoint to #endpoints' do
+      expect { namespace.add_endpoint(endpoint) }.to change {
+        namespace.endpoints.size
+      }.by(1)
+    end
+
+    it 'sets the #namespace attribute of the endpoint to this namespace' do
+      expect { namespace.add_endpoint(endpoint) }.to change {
+        endpoint.namespace
+      }.from(nil).to(namespace)
+    end
+  end
+
+  describe '#get_endpoint' do
+    let(:endpoint_name) { 'name' }
+    let(:endpoint) { OpenStruct.new(name: endpoint_name) }
+
+    context 'when the endpoint was not inserted' do
+      it 'is nil' do
+        expect(namespace.get_endpoint(endpoint_name)).to be_nil
+      end
+    end
+
+    context 'when the endpoint is inside the namespace' do
+      before do
+        namespace.add_endpoint(endpoint)
+      end
+
+      it 'returns the endpoint' do
+        expect(namespace.get_endpoint(endpoint_name)).to eq(endpoint)
+      end
+    end
+
+    context 'when the endpoint is inside a child namespace' do
+      before do
+        child_namespace = namespace.add_anonymous_children_namespace
+        child_namespace.add_endpoint(endpoint)
+      end
+
+      it 'returns the endpoint' do
+        expect(namespace.get_endpoint(endpoint_name)).to eq(endpoint)
+      end
+    end
+  end
+
+  describe '#top_level_namespace?' do
+    subject { used_namespace.top_level_namespace? }
+
+    context 'with a child namespace' do
+      let(:used_namespace) { namespace.add_anonymous_children_namespace }
+      it { should eq(false) }
+    end
+
+    context 'with a normal namespace' do
+      let(:used_namespace) { namespace }
+      it { should eq(true) }
+    end
+  end
+
+  describe '#full_base_path' do
+    context 'for an anonymous namespace with parent' do
+      let(:grand_parent) { Namespace.create('ns') }
+      let(:parent) { grand_parent.add_anonymous_children_namespace }
+      let(:namespace) { parent.add_anonymous_children_namespace }
+
+      before do
+        grand_parent.base_path = '/monkeys'
+        parent.base_path = '/:id'
+        namespace.base_path = '/notifications'
+      end
+
+      it 'is equal to the base_path plus the full_base_path of the parent' do
+        expect(namespace.full_base_path).to eq('/monkeys/:id/notifications')
+      end
+    end
+
+    context 'for a named namespace without parent' do
+      let(:namespace) { Namespace.create('ns') }
+      before { namespace.base_path = '/ns' }
+      it 'is equal to the base_path' do
+        expect(namespace.full_base_path).to eq('/ns')
+      end
+    end
+  end
+
+  describe '#name' do
+    context 'for an anonymous namespace with parent' do
+      let(:grand_parent) { Namespace.create('ns') }
+      let(:parent) { Namespace.create('ns2').tap { |ns| ns.parent_namespace = grand_parent } }
+      let(:namespace) { parent.add_anonymous_children_namespace }
+
+      it 'is equal to the names joint by /' do
+        expect(namespace.name).to eq('ns/ns2')
+      end
+
+      context 'if the namespace has a name too' do
+        let(:namespace) { Namespace.create('ns3').tap { |ns| ns.parent_namespace = parent } }
+        it 'the name is put at the end' do
+          expect(namespace.name).to eq('ns/ns2/ns3')
+        end
+      end
+    end
+
+    context 'for a named namespace without parent' do
+      let(:namespace) { Namespace.create('ns') }
+      it 'is equal to the name alone' do
+        expect(namespace.name).to eq('ns')
+      end
+    end
+  end
+end

data/spec/restspec/endpoints/response_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+include Restspec::Endpoints
+SuperHash = Restspec::Values::SuperHash
+
+describe Response do
+  let(:response) { Response.new(200, {}, body) }
+
+  describe '#read_body' do
+    subject { response.read_body }
+
+    context 'when the body is a scalar' do
+      let(:body) { 'Hello' }
+      it { should be_kind_of(String) }
+      it { should eq(body) }
+    end
+
+    context 'when the body is a hash of scalar values' do
+      let(:body) { { x: 1, y: 'string', z: true }.to_json }
+      it { should be_kind_of(SuperHash) }
+    end
+
+    context 'when the body is an array of scalar values' do
+      let(:info) { [1, 'string', true] }
+      let(:body) { info.to_json }
+      it { should be_kind_of(Array) }
+      it { should eq(info) }
+    end
+
+    context 'when the body is an array of hashes' do
+      let(:info) { [{x: 1}, {x: 2}, {x: 3}] }
+      let(:body) { info.to_json }
+      it { should be_kind_of(Array) }
+      it { should eq(info.as_json) }
+    end
+
+    context 'when the body is a hash of array elements' do
+      let(:body) { { animals: [ { name: 'Lion' }, { name: 'Elephant' } ], number_of_animals: 2 }.to_json }
+      it { should be_kind_of(SuperHash) }
+      it { should have_key(:animals) }
+
+      it 'includes an array of SuperHashes' do
+        subject.animals.each do |animal|
+          expect(animal).to be_kind_of(SuperHash)
+        end
+      end
+    end
+  end
+end

data/spec/restspec/schema/attribute_example_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+include Restspec::Schema
+
+describe AttributeExample do
+  let(:type) { Types::StringType.new }
+  let(:attribute_options) { Hash.new }
+  let(:attribute) { Attribute.new(:name, type, attribute_options) }
+  let(:attribute_example) { AttributeExample.new(attribute) }
+
+  describe '#value' do
+    subject { attribute_example.value }
+
+    context 'when the attribute has an example value specified in him' do
+      let(:attribute_options) { { example: 'mono' } }
+      it { should eq('mono') }
+    end
+
+    context 'when the attribute has an example lambda specified in him' do
+      let(:attribute_options) { { example: ->{ 'mono' } } }
+      it { should eq('mono') }
+    end
+
+    context 'when attribute doesnt have an example option' do
+      before { allow(type).to receive(:example_for).and_return('type example') }
+
+      it { should eq('type example') }
+
+      it 'calls the example_for method of the type' do
+        subject
+        expect(type).to have_received(:example_for).with(attribute)
+      end
+    end
+  end
+end

data/spec/restspec/schema/dsl_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+include Restspec::Schema
+
+describe DSL do
+  let(:dsl) { DSL.new }
+
+  describe '#schema' do
+    let(:single_dsl) { double }
+    let(:schema) { double(name: 'name') }
+
+    before do
+      allow(SingleSchemaDSL).to receive(:new).and_return(single_dsl)
+      allow(single_dsl).to receive(:instance_eval).and_return(single_dsl)
+      allow(single_dsl).to receive(:schema).and_return(schema)
+    end
+
+    it 'creates a SingleSchemaDSL with the given name' do
+      dsl.schema('name') { }
+      expect(SingleSchemaDSL).to have_received(:new)
+    end
+
+    it 'store the schema into the SchemaStore' do
+      dsl.schema('name') { }
+      expect(Restspec::SchemaStore.get('name')).to be_present
+    end
+  end
+end
+
+describe SingleSchemaDSL do
+  let(:dsl) { SingleSchemaDSL.new(name) }
+  let(:name) { 'name' }
+
+  describe '#initialize' do
+    it 'makes the dsl to return a schema with the given name' do
+      expect(dsl.schema.name).to eq(name)
+    end
+  end
+
+  describe '#attribute' do
+    let(:type_instance) { dsl.string }
+
+    it 'creates an attribute with name and type' do
+      dsl.attribute('attr_name', type_instance, {})
+
+      expect(dsl.schema.attributes.size).to eq(1)
+
+      attribute = dsl.schema.attributes.values.first
+
+      expect(attribute.name).to eq('attr_name')
+      expect(attribute.type).to eq(type_instance)
+    end
+
+    context 'when the :for option is just for checks' do
+      let(:attribute) { dsl.attribute('attr_name', type_instance, for: [:checks]) }
+
+      it 'is not allowed to generate examples' do
+        expect(attribute.can_generate_examples?).to eq(false)
+      end
+
+      it 'is allowed to run in validations' do
+        expect(attribute.can_be_checked?).to eq(true)
+      end
+    end
+
+    context 'when the :for option is just for examples' do
+      let(:attribute) { dsl.attribute('attr_name', type_instance, for: [:examples]) }
+
+      it 'is allowed to generate examples' do
+        expect(attribute.can_generate_examples?).to eq(true)
+      end
+
+      it 'is not allowed to run in validations' do
+        expect(attribute.can_be_checked?).to eq(false)
+      end
+    end
+  end
+end