frenetic 0.0.12 → 0.0.20.alpha.0

data/spec/configuration_spec.rb

@@ -0,0 +1,99 @@
+describe Frenetic::Configuration do
+  let(:cfg) { Hash.new }
+
+  subject(:instance) { described_class.new cfg }
+
+  describe '#adapter' do
+    subject { instance.adapter }
+
+    it { should == :net_http }
+  end
+
+  describe '#attributes' do
+    subject { instance.attributes }
+
+    it { should include :adapter }
+    it { should include :api_token }
+    it { should include :cache }
+    it { should include :headers }
+    it { should include :password }
+    it { should include :url }
+    it { should include :username }
+  end
+
+  describe '#api_token' do
+    let(:cfg) do
+      { api_token:'API_TOKEN' }
+    end
+
+    subject { instance.api_token }
+
+    it { should == 'API_TOKEN' }
+  end
+
+  describe '#cache' do
+    subject { instance.cache }
+
+    context 'with a value of :rack' do
+      let(:cfg) do
+        { cache: :rack }
+      end
+
+      it 'should return Rack::Cache options' do
+        subject.should include metastore:'file:tmp/rack/meta'
+        subject.should include entitystore:'file:tmp/rack/body'
+        subject.should include ignore_headers:%w{Authorization Set-Cookie X-Content-Digest}
+      end
+    end
+  end
+
+  describe '#headers' do
+    let(:cfg) do
+      { headers:{ accept:'MIME', x_foo:'BAR' } }
+    end
+
+    subject { instance.headers }
+
+    it 'should properly merge in nested header values' do
+      subject.should include :user_agent
+      subject.should include accept:'MIME'
+      subject.should include x_foo:'BAR'
+    end
+  end
+
+  describe '#password' do
+    subject { instance.password }
+
+    context 'with a specifed Api key' do
+      let(:cfg) do
+        { api_key:'API_KEY' }
+      end
+
+      it { should == 'API_KEY' }
+    end
+  end
+
+  describe '#url' do
+    let(:cfg) do
+      { url:'http://example.org' }
+    end
+
+    subject { instance.url }
+
+    it { should be_a Addressable::URI }
+
+    its(:to_s) { should == 'http://example.org' }
+  end
+
+  describe '#username' do
+    subject { instance.username }
+
+    context 'with a specifed App Id' do
+      let(:cfg) do
+        { app_id:'APP_ID' }
+      end
+
+      it { should == 'APP_ID' }
+    end
+  end
+end

data/spec/fixtures/test_api_requests.rb

@@ -0,0 +1,88 @@
+require 'json'
+
+class HttpStubs
+
+  def initialize( rspec )
+    @rspec = rspec
+  end
+
+  def defaults
+    {
+      status:  200,
+      headers: { 'Content-Type'=>'application/json' },
+      body:    {}
+    }
+  end
+
+  def response( params = {} )
+    defaults.merge( params ).tap do |p|
+      p[:body] = p[:body].to_json
+    end
+  end
+
+  def api_server_error
+    @rspec.stub_request( :any, 'example.com/api' )
+      .to_return response( body:{error:'500 Server Error'}, status:500 )
+  end
+
+  def api_client_error( type = :json )
+    body = '404 Not Found'
+
+    body = { 'error' => body }.to_json if type == :json
+
+    @rspec.stub_request( :any, 'example.com/api' )
+      .to_return defaults.merge( body:body, status:404 )
+  end
+
+  def api_description
+    @rspec.stub_request( :any, 'example.com/api' )
+      .to_return response( body:schema )
+  end
+
+  def unknown_resource
+    @rspec.stub_request( :get, 'example.com/api/my_temp_resources/1' )
+      .to_return response( body:{ 'error' => '404 Not Found' }, status:404 )
+  end
+
+  def known_resource
+    @rspec.stub_request( :get, 'example.com/api/my_temp_resources/1' )
+      .to_return response( body:{ 'name' => 'Resource Name' } )
+  end
+
+  def schema
+    {
+      _embedded: {
+        schema: {
+          my_temp_resource: {
+            description: 'Humanized resource description',
+            properties: {
+              name: 'string'
+            }
+          }
+        }
+      },
+      _links: {
+        schema: {
+          href: '/api/schema'
+        },
+        my_temp_resources: {
+          href: '/api/my_temp_resources'
+        },
+        my_temp_resource: {
+          href: '/api/my_temp_resources/{id}',
+          templated: true
+        },
+        abstract_resource: {
+          href: '/api/abstract_resource'
+        }
+      }
+    }
+  end
+
+end
+
+RSpec.configure do |c|
+  c.before :all do
+    @stubs = HttpStubs.new( self )
+  end
+end

data/spec/frenetic_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Frenetic do
+  let(:test_cfg) do
+    {
+      url:'http://example.com/api'
+    }
+  end
+
+  subject(:instance) { described_class.new( test_cfg ) }
+
+  describe '#connection' do
+    subject { instance.connection }
+
+    it { should be_a Faraday::Connection }
+
+    context 'configured with a :username' do
+      let(:test_cfg) { super().merge username:'foo' }
+
+      subject { super().builder.handlers }
+
+      it { should include Faraday::Request::BasicAuthentication }
+    end
+
+    context 'configured with a :api_token' do
+      let(:test_cfg) { super().merge api_token:'API_TOKEN' }
+
+      subject { super().builder.handlers }
+
+      it { should include Faraday::Request::TokenAuthentication }
+    end
+
+    context 'configured to use Rack::Cache' do
+      let(:test_cfg) { super().merge cache: :rack }
+
+      subject { super().builder.handlers }
+
+      it { should include FaradayMiddleware::RackCompatible }
+    end
+
+    context 'when Frenetic is initialized with a block' do
+      it 'should yield the Faraday builder to the block argument' do
+        builder = nil
+
+        described_class.new(test_cfg) do |b|
+          builder = b
+        end.connection
+
+        builder.should be_a Faraday::Connection
+      end
+    end
+  end
+
+  describe '#description' do
+    subject { instance.description }
+
+    context 'with a URL that returns a' do
+      context 'valid response' do
+        before { @stubs.api_description }
+
+        it { should include '_embedded', '_links' }
+      end
+
+      context 'server error' do
+        before { @stubs.api_server_error }
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error Frenetic::ServerError
+        end
+      end
+
+      context 'client error' do
+        before { @stubs.api_client_error :json }
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error Frenetic::ClientError
+        end
+      end
+
+      context 'JSON parsing error' do
+        before { @stubs.api_client_error :text }
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error Frenetic::ParsingError
+        end
+      end
+    end
+  end
+
+  describe '.schema' do
+    subject { instance.schema }
+
+    before { @stubs.api_description }
+
+    it { should include 'my_temp_resource' }
+  end
+
+  describe '#get' do
+    subject { instance.get '/foo' }
+
+    it 'should delegate to Faraday' do
+      instance.connection.should_receive :get
+
+      subject
+    end
+  end
+
+  describe '#put' do
+    subject { instance.put '/foo' }
+
+    it 'should delegate to Faraday' do
+      instance.connection.should_receive :put
+
+      subject
+    end
+  end
+
+  describe '#post' do
+    subject { instance.post '/foo' }
+
+    it 'should delegate to Faraday' do
+      instance.connection.should_receive :post
+
+      subject
+    end
+  end
+
+  describe '#delete' do
+    subject { instance.delete '/foo' }
+
+    it 'should delegate to Faraday' do
+      instance.connection.should_receive :delete
+
+      subject
+    end
+  end
+end

data/spec/middleware/hal_json_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Frenetic::Middleware::HalJson do
+
+  def process(body, content_type = nil, options = {}, status = 200)
+    env = {
+      body:             body,
+      request:          options,
+      response_headers: Faraday::Utils::Headers.new( headers ),
+      status:           status
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+
+    middleware.call env
+  end
+
+  let(:options) { Hash.new }
+
+  let(:headers) { Hash.new }
+
+  let(:middleware) do
+    described_class.new(lambda {|env|
+      Faraday::Response.new(env)
+    }, options)
+  end
+
+  it 'does not change nil body' do
+    expect(process(nil).body).to be_nil
+  end
+
+  it 'nullifies empty body' do
+    expect(process('').body).to be_nil
+  end
+
+  context 'with a HAL+JSON body' do
+    let(:body) do
+      {
+        'name' => 'My Name',
+        '_embedded' => {
+          'other_resource' => {
+            'label' => 'My Label'
+          }
+        },
+        '_links' => {
+          'self' => {
+            'href' => '/api/my_temp_resource/1'
+          }
+        }
+      }.to_json
+    end
+
+    subject { process(body) }
+
+    it 'should parse the body' do
+      expect(subject.body).to include 'name' => 'My Name'
+    end
+  end
+
+  context 'with error response' do
+    subject { process(error, nil, {}, status) }
+
+    context 'from the server' do
+      let(:status) { 500 }
+
+      let(:error) { { 'status' => status.to_s, error:'500 Server Error' }.to_json }
+
+      it 'should raise an error' do
+        expect{ subject }.to raise_error Frenetic::ServerError
+      end
+    end
+
+    context 'cause by the client' do
+      let(:status) { 404 }
+
+      let(:error) { { 'status' => status.to_s, error:'404 Not Found' }.to_json }
+
+      it 'should raise an error' do
+        expect{ subject }.to raise_error Frenetic::ClientError
+      end
+    end
+  end
+
+end

data/spec/resource_collection_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Frenetic::ResourceCollection do
+  let(:test_cfg) do
+    {
+      url:'http://example.com/api'
+    }
+  end
+
+  let(:my_temp_resource) do
+    cfg = test_cfg
+
+    Class.new(Frenetic::Resource) do
+      api_client { Frenetic.new(cfg) }
+    end
+  end
+
+  before do
+    stub_const 'MyTempResource', my_temp_resource
+
+    @stubs.api_description
+  end
+
+  let(:collection_response) {
+    {
+      '_embedded' => {
+        'my_temp_resources' => [
+          { 'id' => 1, 'name' => 'First' },
+          { 'id' => 2, 'name' => 'Last'  }
+        ]
+      },
+      '_links' => {
+        'self' => {
+          'href' => '/api/my_temp_resources'
+        },
+        'my_temp_resource' => {
+          'href' => '/api/my_temp_resources/{id}',
+          'templated' => true
+        }
+      }
+    }
+  }
+
+  subject(:instance) { described_class.new(MyTempResource, collection_response) }
+
+  it 'should know where the resources are located' do
+    subject.collection_key.should == 'my_temp_resources'
+  end
+
+  it 'should know which resource it represents' do
+    subject.resource_type.should == 'my_temp_resource'
+  end
+
+  it 'should extract the embedded resources' do
+    subject.size.should == 2
+  end
+
+  it 'should parse the embedded resources' do
+    subject.first.should be_a MyTempResource
+  end
+
+  it 'should be able to make API calls' do
+    subject.api.should be_an_instance_of Frenetic
+  end
+
+  it 'should have links' do
+    subject.links.should_not be_empty
+  end
+
+  describe '#get' do
+    before { @stubs.known_resource }
+
+    subject { super().get(1) }
+
+    it 'should GET the full representation' do
+      subject.should be_an_instance_of MyTempResource
+    end
+  end
+
+end