bootic_client 0.0.1

data/lib/bootic_client.rb

@@ -0,0 +1,47 @@
+require 'logger'
+require "bootic_client/version"
+require "bootic_client/entity"
+require "bootic_client/relation"
+require "bootic_client/client"
+
+module BooticClient
+
+  AUTH_HOST = 'https://auth.bootic.net'.freeze
+  API_ROOT = 'https://api.bootic.net/v1'.freeze
+
+  class << self
+
+    attr_accessor :client_secret, :client_id, :logging, :cache_store
+    attr_writer :auth_host, :api_root, :logger
+
+    def strategies
+      @strategies ||= {}
+    end
+
+    def client(strategy_name, client_opts = {}, &on_new_token)
+      opts = client_opts.dup
+      opts[:logging] = logging
+      opts[:logger] = logger if logging
+      opts[:cache_store] = cache_store if cache_store
+      require "bootic_client/strategies/#{strategy_name}"
+      strategies.fetch(strategy_name.to_sym).new self, opts, &on_new_token
+    end
+
+    def auth_host
+      @auth_host || AUTH_HOST
+    end
+
+    def api_root
+      @api_root || API_ROOT
+    end
+
+    def logger
+      @logger || ::Logger.new(STDOUT)
+    end
+
+    def configure(&block)
+      yield self
+    end
+  end
+
+end

data/spec/authorized_strategy_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'jwt'
+
+describe 'BooticClient::Strategies::Authorized' do
+  require 'webmock/rspec'
+
+  let(:client_id) {'aaa'}
+  let(:client_secret) {'bbb'}
+
+  def jwt_assertion(expired_token, now)
+    JWT.encode({
+      iss: client_id,
+      aud: 'api',
+      prn: expired_token,
+      exp: now.utc.to_i + 5
+    }, client_secret, 'HS256')
+  end
+
+  def stub_api_root(access_token, status, body)
+    stub_request(:get, "https://api.bootic.net/v1").
+      with(headers: {'Accept'=>'*/*', 'Authorization' => "Bearer #{access_token}"}).
+      to_return(status: status, :body => JSON.dump(body))
+  end
+
+  def stub_auth(expired_token, status, body)
+    now = Time.now
+    Time.stub(:now).and_return now
+
+    stub_request(:post, "https://auth.bootic.net/oauth/token").
+      with(body: {
+        "assertion" => jwt_assertion(expired_token, now), 
+        "assertion_type" => "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        "client_id" => "",
+        "client_secret" => "", 
+        "grant_type" => "assertion", 
+        "scope"=>""
+      },
+      headers: {
+        'Content-Type'=>'application/x-www-form-urlencoded'
+      }).
+      to_return(status: status, body: JSON.dump(body), headers: {'Content-Type' => 'application/json'})
+  end
+
+  let(:store){ Hash.new }
+  let(:root_data) {
+    {
+      '_links' => {
+        'shops' => {'href' => 'https://api.bootic.net/v1/products'}
+      },
+      'message' => "Hello!"
+    }
+  }
+
+  describe 'with missing client credentials' do
+    it 'raises error' do
+      expect{
+        BooticClient.client(:authorized)
+      }.to raise_error
+    end
+  end
+
+  describe 'with no access_token' do
+    it 'raises error' do
+      expect{
+        BooticClient.client(:authorized)
+      }.to raise_error
+    end
+  end
+
+  describe 'with valid client credentials and access_token' do
+
+    let(:client) do
+      BooticClient.client(:authorized, access_token: 'abc') do |new_token|
+        store[:access_token] = new_token
+      end
+    end
+
+    before do
+      BooticClient.configure do |c|
+        c.client_id = client_id
+        c.client_secret = client_secret
+      end
+    end
+
+    context 'with valid token' do
+      before do
+        @root_request = stub_api_root('abc', 200, message: 'Hello!')
+      end
+
+      it 'does not request new token to auth service' do
+        root = client.root
+        expect(@root_request).to have_been_requested
+        expect(root.message).to eql('Hello!')
+      end
+    end
+
+    context 'with expired token' do
+      before do
+        @failed_root_request = stub_api_root('abc', 401, message: 'Unauthorized')
+        @auth_request = stub_auth('abc', 200, access_token: 'foobar')
+        @successful_root_request = stub_api_root('foobar', 200, root_data)
+      end
+
+      it 'attempts unauthorised API request, refreshes token from auth an tries again' do
+        root = client.root
+        expect(@failed_root_request).to have_been_requested
+        expect(@auth_request).to have_been_requested
+        expect(root.message).to eql('Hello!')
+      end
+
+      it 'yields new token to optional block' do
+        client.root
+        expect(store[:access_token]).to eql('foobar')
+      end
+    end
+  end
+end

data/spec/bootic_client_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe BooticClient do
+  it 'should have a version number' do
+    expect(BooticClient::VERSION).not_to eql(nil)
+  end
+
+end

data/spec/client_credentials_strategy_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe 'BooticClient::Strategies::ClientCredentials' do
+  require 'webmock/rspec'
+
+  let(:store){ Hash.new }
+  let(:root_data) {
+    {
+      '_links' => {
+        'shops' => {'href' => 'https://api.bootic.net/v1/products'}
+      },
+      'message' => "Hello!"
+    }
+  }
+
+  describe 'with missing client credentials' do
+    it 'raises error' do
+      expect{
+        BooticClient.client(:client_credentials, scope: 'admin')
+      }.to raise_error
+    end
+  end
+
+  describe 'with valid client credentials' do
+
+    def stub_auth(status, body)
+      stub_request(:post, "https://aaa:bbb@auth.bootic.net/oauth/token").
+        with(body: {"grant_type"=>"client_credentials", 'scope' => 'admin'}).
+        to_return(status: status, body: JSON.dump(body), headers: {'Content-Type' => 'application/json'})
+    end
+
+    def stub_api_root(access_token, status, body)
+      stub_request(:get, "https://api.bootic.net/v1").
+        with(headers: {'Accept'=>'*/*', 'Authorization' => "Bearer #{access_token}"}).
+        to_return(status: status, :body => JSON.dump(body))
+    end
+
+    before do
+      BooticClient.configure do |c|
+        c.client_id = 'aaa'
+        c.client_secret = 'bbb'
+      end
+    end
+
+    context 'with no previous access token' do
+      let(:client) do
+        BooticClient.client(:client_credentials, scope: 'admin') do |new_token|
+          store[:access_token] = new_token
+        end
+      end
+
+      before do
+        @auth_request = stub_auth(200, access_token: 'foobar')
+        stub_api_root 'foobar', 200, root_data
+      end
+
+      it 'requests access token via client_credentials flow' do
+        root = client.root
+        expect(@auth_request).to have_been_requested
+        expect(root.message).to eql('Hello!')
+      end
+
+      it 'yields new token to optional block' do
+        client.root
+        expect(store[:access_token]).to eql('foobar')
+      end
+    end
+
+    context 'with an expired access token' do
+      let(:client) do
+        BooticClient.client(:client_credentials, scope: 'admin', access_token: 'abc') do |new_token|
+          store[:access_token] = new_token
+        end
+      end
+
+      before do
+        @failed_root_request = stub_api_root('abc', 401, message: 'Unauthorized')
+        @auth_request = stub_auth(200, access_token: 'foobar')
+        @successful_root_request = stub_api_root('foobar', 200, root_data)
+      end
+
+      it 'attempts unauthorised API request, gets token from auth an tries again' do
+        root = client.root
+        expect(@failed_root_request).to have_been_requested
+        expect(@auth_request).to have_been_requested
+        expect(root.message).to eql('Hello!')
+      end
+
+      it 'yields new token to optional block' do
+        client.root
+        expect(store[:access_token]).to eql('foobar')
+      end
+    end
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'json'
+
+describe BooticClient::Client do
+  require 'webmock/rspec'
+
+  describe 'valid response' do
+    let(:root_url) { 'https://api.bootic.net/v1' }
+    let(:client) { BooticClient::Client.new(root_url, access_token: 'xxx') }
+    let(:response_headers) {
+      {'Content-Type' => 'application/json', 'Last-Modified' => 'Sat, 07 Jun 2014 12:10:33 GMT'}
+    }
+    let(:root_data) {
+      {
+        '_links' => {
+          'shops' => {'href' => 'https://api.bootic.net/v1/products'}
+        },
+        'message' => "Hello!"
+      }
+    }
+
+    describe '#get' do
+
+      context 'fresh' do
+        before do
+          stub_request(:get, root_url)
+            .to_return(status: 200, body: JSON.dump(root_data), headers: response_headers)
+        end
+
+        let!(:response) { client.get(root_url) }
+
+        it 'returns parsed Faraday response' do
+          expect(response).to be_kind_of(Faraday::Response)
+          expect(response.status).to eql(200)
+          response.body.tap do |b|
+            expect(b['_links']['shops']).to eql({'href' => 'https://api.bootic.net/v1/products'})
+          end
+        end
+
+        context 'and then cached' do
+          before do
+            @cached_request = stub_request(:get, root_url)
+              .with(headers: {'If-Modified-Since' => 'Sat, 07 Jun 2014 12:10:33 GMT'})
+              .to_return(status: 304, body: '', headers: response_headers)
+          end
+
+          it 'returns cached response' do
+            r = client.get(root_url)
+            expect(@cached_request).to have_been_requested
+
+            expect(r.status).to eql(200)
+            r.body.tap do |b|
+              expect(b['_links']['shops']).to eql({'href' => 'https://api.bootic.net/v1/products'})
+            end
+          end
+        end
+      end
+
+      context 'errors' do
+        describe 'no access token' do
+          it 'raises error' do
+            expect{
+              BooticClient::Client.new(root_url).get(root_url)
+            }.to raise_error(BooticClient::NoAccessTokenError)
+          end
+        end
+
+        describe '500 Server error' do
+          before do
+            stub_request(:get, root_url)
+              .to_return(status: 500, body: JSON.dump(message: 'Server error'), headers: response_headers)
+          end
+
+          it 'raises exception' do
+            expect{
+              client.get(root_url)
+            }.to raise_error(BooticClient::ServerError)
+          end
+        end
+
+        describe '404 Not Found' do
+          before do
+            stub_request(:get, root_url)
+              .to_return(status: 404, body: JSON.dump(message: 'not Found'), headers: response_headers)
+          end
+
+          it 'raises exception' do
+            expect{
+              client.get(root_url)
+            }.to raise_error(BooticClient::NotFoundError)
+          end
+        end
+
+        describe '401 Unauthorized' do
+          before do
+            stub_request(:get, root_url)
+              .to_return(status: 401, body: JSON.dump(message: 'Unauthorised'), headers: response_headers)
+          end
+
+          it 'raises exception' do
+            expect{
+              client.get(root_url)
+            }.to raise_error(BooticClient::UnauthorizedError)
+          end
+        end
+
+        describe '403 Access Forbidden' do
+          before do
+            stub_request(:get, root_url)
+              .to_return(status: 403, body: JSON.dump(message: 'Access Forbidden'), headers: response_headers)
+          end
+
+          it 'raises exception' do
+            expect{
+              client.get(root_url)
+            }.to raise_error(BooticClient::AccessForbiddenError)
+          end
+        end
+      end
+
+    end
+
+    describe '#get_and_wrap' do
+      before do
+        stub_request(:get, root_url)
+          .with(query: {foo: 'bar'})
+          .to_return(status: 200, body: JSON.dump(root_data), headers: response_headers)
+      end
+
+      it 'wraps JSON response in entity' do
+        wrapper = double('Wrapper Class')
+        entity = double('Entity')
+        expect(wrapper).to receive(:new).with(root_data, client).and_return entity
+        expect(client.get_and_wrap(root_url, wrapper, foo: 'bar')).to eql(entity)
+      end
+    end
+
+  end
+end

data/spec/entity_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe BooticClient::Entity do
+  let(:client) { double(:client) }
+  let(:list_payload) do
+    {
+      'total_items' => 10,
+      'per_page' => 2,
+      'page' => 1,
+      'an_object' => {
+        'name' => 'Foobar',
+        'age' => 22
+      },
+      '_links' => {
+        'self' => {'href' => '/foo'},
+        'next' => { 'href' => '/foo?page=2'},
+        'btc:products' => {'href' => '/all/products'},
+        'btc:search' => {'href' => '/search{?q}', 'templated' => true},
+        'curies' => [
+          {
+            'name' => "btc",
+            'href' => "https://developers.bootic.net/rels/{rel}",
+            'templated' => true
+          }
+        ]
+      },
+      "_embedded" => {
+        'items' => [
+          {
+            'title' => 'iPhone 4',
+            'price' => 12345,
+            '_links' => {
+              'self' => {href: '/products/iphone4'},
+              'btc:delete_product' => {'href' => '/products/12345'}
+            },
+            '_embedded' => {
+              'shop' => {
+                'name' => 'Acme'
+              }
+            }
+          },
+
+          {
+            'title' => 'iPhone 5',
+            'price' => 12342,
+            '_links' => {
+              'self' => {href: '/products/iphone5'}
+            },
+            '_embedded' => {
+              'shop' => {
+                'name' => 'Apple'
+              }
+            }
+          }
+          
+        ] # / items
+      }
+    }
+  end
+
+  context 'parsing JSON HAL' do
+    let(:entity) { BooticClient::Entity.new(list_payload, client) }
+
+    it 'knows about plain properties' do
+      expect(entity.total_items).to eql(10)
+      expect(entity.per_page).to eql(2)
+      expect(entity.page).to eql(1)
+    end
+
+    it 'wraps object properties as entities' do
+      expect(entity.an_object.name).to eql('Foobar')
+      expect(entity.an_object.age).to eql(22)
+    end
+
+    it 'has a #properties object' do
+      expect(entity.properties[:total_items]).to eql(10)
+    end
+
+    it 'responds to #has?' do
+      expect(entity.has?(:total_items)).to eql(true)
+      expect(entity.has?(:items)).to eql(true)
+      expect(entity.has?(:foobar)).to eql(false)
+    end
+
+    describe 'embedded entities' do
+
+      it 'has a #entities object' do
+        expect(entity.entities[:items]).to be_a(Array)
+        expect(entity.entities[:items].first.entities[:shop]).to be_kind_of(BooticClient::Entity)
+      end
+
+      it 'are exposed like normal attributes' do
+        expect(entity.items).to be_kind_of(Array)
+        entity.items.first.tap do |product|
+          expect(product).to be_kind_of(BooticClient::Entity)
+          expect(product.title).to eql('iPhone 4')
+        end
+      end
+
+      it 'recursively builds embedded entities' do
+        product = entity.items.first
+        product.shop.tap do |shop|
+          expect(shop).to be_kind_of(BooticClient::Entity)
+          expect(shop.name).to eql('Acme')
+        end
+      end
+    end #/ embedded entities
+
+    describe 'link relations' do
+      it 'responds to #has? for link relations' do
+        expect(entity.has?(:next)).to eql(true)
+      end
+
+      it 'builds relation objects' do
+        expect(entity.rels[:next]).to be_kind_of(BooticClient::Relation)
+        expect(entity.rels[:next].href).to eql('/foo?page=2')
+      end
+
+      it 'understands namespaced cURIes' do
+        expect(entity.rels[:products]).to be_kind_of(BooticClient::Relation)
+        expect(entity.rels[:products].href).to eql('/all/products')
+      end
+
+      it 'adds docs if cURIes available' do
+        expect(entity.rels[:products].docs).to eql('https://developers.bootic.net/rels/products')
+      end
+
+      it 'adds docs if cURIes available even in nested entities' do
+        prod = entity.items.first
+        expect(prod.rels[:delete_product].docs).to eql('https://developers.bootic.net/rels/delete_product')
+      end
+
+      context 'eagerly fetching rels' do
+        let(:next_page) { BooticClient::Entity.new({'page' => 2}, client) }
+
+        it 'exposes link target resources as normal properties' do
+          expect(client).to receive(:get_and_wrap).with('/foo?page=2', BooticClient::Entity, {}).and_return next_page
+          entity.next.tap do |next_entity|
+            expect(next_entity).to be_kind_of(BooticClient::Entity)
+            expect(next_entity.page).to eql(2)
+          end
+        end
+
+        it 'takes optional URI parameters' do
+          expect(client).to receive(:get_and_wrap).with('/search?q=foo', BooticClient::Entity).and_return next_page
+          entity.search(q: 'foo').tap do |next_entity|
+            expect(next_entity).to be_kind_of(BooticClient::Entity)
+            expect(next_entity.page).to eql(2)
+          end
+        end
+      end
+
+    end
+
+    describe 'iterating' do
+      it 'iterates items if it is a list' do
+        prods = []
+        entity.each{|pr| prods << pr}
+        expect(prods).to match_array(entity.items)
+      end
+
+      it 'iterates itself if not a list' do
+        ent = BooticClient::Entity.new({'foo' => 'bar'}, client)
+        ents = []
+        ent.each{|e| ents << e}
+        expect(ents).to match_array([ent])
+      end
+    end
+  end
+
+end

data/spec/memcache_storage_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'bootic_client/stores/memcache'
+
+describe BooticClient::Stores::Memcache do
+  let(:dalli) { double('Dalli') }
+  let(:store) { BooticClient::Stores::Memcache.new(['localhost:1112'], foo: 'bar') }
+
+  before do
+    Dalli::Client.stub(:new).with(['localhost:1112'], foo: 'bar').and_return dalli
+  end
+
+  shared_examples_for 'dalli :get' do |method_name|
+    it 'delegates to Dalli client #get' do
+      expect(dalli).to receive(:get).with('foo').and_return 'bar'
+      expect(store.send(method_name, 'foo')).to eql('bar')
+    end
+  end
+
+  shared_examples_for 'dalli :set' do |method_name|
+    it 'delegates to Dalli client #set' do
+      expect(dalli).to receive(:set).with('foo', 'bar', 123).and_return 'bar'
+      expect(store.send(method_name, 'foo', 'bar', 123)).to eql('bar')
+    end
+  end
+
+  describe '#initialize' do
+    it 'creates a Dalli instance' do
+      expect(Dalli::Client).to receive(:new).with(['localhost:1112'], foo: 'bar').and_return dalli
+      expect(store.client).to eql(dalli)
+    end
+  end
+
+  describe '#read' do
+    it_behaves_like 'dalli :get', :read
+  end
+
+  describe '#get' do
+    it_behaves_like 'dalli :get', :get
+  end
+
+  describe '#write' do
+    it_behaves_like 'dalli :set', :write
+  end
+
+  describe '#set' do
+    it_behaves_like 'dalli :set', :set
+  end
+
+  describe '#stats' do
+    it 'delegates to Dalli client #stats' do
+      expect(dalli).to receive(:stats).and_return 'foobar'
+      expect(store.stats).to eql('foobar')
+    end
+  end
+end

data/spec/relation_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe BooticClient::Relation do
+  let(:client) { double(:client) }
+  let(:relation) { BooticClient::Relation.new({'href' => '/foo/bars', 'type' => 'application/json', 'title' => 'A relation', 'name' => 'self'}, client) }
+
+  describe 'attributes' do
+    it 'has readers for known relation attributes' do
+      expect(relation.href).to eql('/foo/bars')
+      expect(relation.type).to eql('application/json')
+      expect(relation.title).to eql('A relation')
+      expect(relation.name).to eql('self')
+    end
+  end
+
+  describe '#get' do
+    let(:entity) { BooticClient::Entity.new({'title' => 'Foobar'}, client) }
+
+    it 'fetches data and returns entity' do
+      client.stub(:get_and_wrap).with('/foo/bars', BooticClient::Entity, {}).and_return entity
+      expect(relation.get).to eql(entity)
+    end
+
+    context 'without URI templates' do
+      let(:relation) { BooticClient::Relation.new({'href' => '/foos/bar', 'type' => 'application/json', 'title' => 'A relation'}, client) }
+
+      it 'is not templated' do
+        expect(relation.templated?).to eql(false)
+      end
+
+      it 'passes query string to client' do
+        expect(client).to receive(:get_and_wrap).with('/foos/bar', BooticClient::Entity, id: 2, q: 'test', page: 2).and_return entity
+        expect(relation.get(id: 2, q: 'test', page: 2)).to eql(entity)
+      end
+    end
+
+    context 'with URI templates' do
+      let(:relation) { BooticClient::Relation.new({'href' => '/foos/{id}{?q,page}', 'type' => 'application/json', 'title' => 'A relation', 'templated' => true}, client) }
+
+      it 'is templated' do
+        expect(relation.templated?).to eql(true)
+      end
+
+      it 'works with defaults' do
+        expect(client).to receive(:get_and_wrap).with('/foos/', BooticClient::Entity).and_return entity
+        expect(relation.get).to eql(entity)
+      end
+
+      it 'interpolates tokens' do
+        expect(client).to receive(:get_and_wrap).with('/foos/2?q=test&page=2', BooticClient::Entity).and_return entity
+        expect(relation.get(id: 2, q: 'test', page: 2)).to eql(entity)
+      end
+    end
+  end
+end