artirix_data_models 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad3a2bfa1f8645d66fa869c8f181c0967c04e6e6
-  data.tar.gz: 8d35e9ea6f56f73461d0a3ccb77682a663507302
+  metadata.gz: 40b6f9f87c468b62e4110b789710aa52c26733a2
+  data.tar.gz: 2a2099654a9c5b6c93d78c3ea5b1e614353ad07e
 SHA512:
-  metadata.gz: 9b326d4c9a5461c59db3b7d1dd76e9d1ddbdbd85bf93e024dfa1181e0ef1f8024c7688a6d114a6b6754586b62c525e5c1c1b2ffc516d2f3b15013e6a71bd2580
-  data.tar.gz: dee1cffa2dfc3d207cb62c3501d43d3b46b43900ab0f1cecc341842e6ac92041fe29e8766aaca97a381fe1af56571821a0294322dce69da7e8fe33b935452562
+  metadata.gz: 287d064bc3dd3579a378de1b229ae910033c171877031a3407490b93d747cb6a75006897444bd96413accc451be836defade734d6849958fe614a5d57d255cd9
+  data.tar.gz: 33fdb76a7ae986cceeccd6d03a21558109b57c815060d208c899a72f94cc10f5c66df701570d2e16a9641f83a3a80f2c5a02a4d3ad927ccc2728ef4681bf880b

data/README.md

@@ -270,6 +270,32 @@ end
 
 ## Changes
 
+### 0.17.0
+
+`DataGateway` now has `authorization_bearer` and `authorization_token_hash` options:
+- they can be passed on the gateway creation and they will be used on all elements
+- they can be overridden on a given gateway call:
+-- if passed `nil` it will use the value on object creation, if present.
+-- if passed `false` it will not use it (can override a value on object creation).
+
+The values can also be added on config to the connection (but then the `false` override won't work). The authorization will be set on the connection level instead on the request level.
+
+```ruby
+SimpleConfig.for(:site) do
+  group :data_gateway do
+    set :token_hash, { email: 'something', token: 'whatever }
+  end
+end
+```
+
+```ruby
+SimpleConfig.for(:site) do
+  group :data_gateway do
+    set :bearer_token, 'SomeBearerToken'
+  end
+end
+```
+
 ### 0.16.0
 `ArtirixDataModels::Model::CacheKey` now does not assume that you are in a complete model. It tries to use `model_dao_name`, `primary_key`, `id`, `_timestamp` and `updated_at`, but it has default for each section. Change to be able to make a model with `OnlyData` compatible with `AMS` using [`artirix_data_models-ams`](https://github.com/artirix/artirix_data_models-ams/) gem
 

data/lib/artirix_data_models/gateways/data_gateway.rb

@@ -1,9 +1,16 @@
 class ArtirixDataModels::DataGateway
   attr_reader :connection, :post_as_json
 
-  def initialize(connection: nil, post_as_json: true)
-    @connection   = connection || DefaultConnectionLoader.default_connection
-    @post_as_json = !!post_as_json
+  def initialize(connection: nil,
+                 post_as_json: true,
+                 timeout: nil,
+                 authorization_bearer: nil,
+                 authorization_token_hash: nil)
+    @connection               = connection || DefaultConnectionLoader.default_connection
+    @post_as_json             = !!post_as_json
+    @authorization_bearer     = authorization_bearer
+    @authorization_token_hash = authorization_token_hash
+    @timeout                  = timeout
   end
 
   def get(path, **opts)
@@ -22,13 +29,40 @@ class ArtirixDataModels::DataGateway
     call :delete, path, **opts
   end
 
-  def call(method, path, json_body: true, response_adaptor: nil, body: nil, fake: false, fake_response: nil, cache_adaptor: nil, timeout: nil, **_ignored_options)
+  def call(method,
+           path,
+           json_body: true,
+           response_adaptor: nil,
+           body: nil,
+           fake: false,
+           fake_response: nil,
+           cache_adaptor: nil,
+           timeout: nil,
+           authorization_bearer: nil,
+           authorization_token_hash: nil,
+           **_ignored_options)
     if fake
       result = fake_response.respond_to?(:call) ? fake_response.call : fake_response
+
     elsif cache_adaptor.present?
-      result = cache_adaptor.call { perform(method, path: path, body: body, json_body: json_body, timeout: timeout) }
+      result = cache_adaptor.call do
+        perform method,
+                path:                     path,
+                body:                     body,
+                json_body:                json_body,
+                timeout:                  timeout,
+                authorization_bearer:     authorization_bearer,
+                authorization_token_hash: authorization_token_hash
+      end
+
     else
-      result = perform(method, path: path, body: body, json_body: json_body, timeout: timeout)
+      result = perform method,
+                       path:                     path,
+                       body:                     body,
+                       json_body:                json_body,
+                       timeout:                  timeout,
+                       authorization_bearer:     authorization_bearer,
+                       authorization_token_hash: authorization_token_hash
     end
 
     parse_response result:           result,
@@ -55,15 +89,47 @@ class ArtirixDataModels::DataGateway
     perform :delete, path: path, **opts
   end
 
-  def perform(method, path:, body: nil, json_body: true, timeout: nil)
-    response = connect(method, path: path, body: body, json_body: json_body, timeout: timeout)
+  def perform(method,
+              path:,
+              body: nil,
+              json_body: true,
+              timeout: nil,
+              authorization_bearer: nil,
+              authorization_token_hash: nil)
+
+    pars = {
+      path:                     path,
+      body:                     body,
+      json_body:                json_body,
+      timeout:                  timeout,
+      authorization_bearer:     authorization_bearer,
+      authorization_token_hash: authorization_token_hash
+    }
+
+    response = connect(method, pars)
     treat_response(response, method, path)
   end
 
-  def connect(method, path:, body: nil, json_body: true, timeout: nil)
+  # for options `timeout`, `authorization_bearer` and `authorization_token_hash`:
+  # if `nil` is passed (or param is omitted) it will try to use the default passed on the gateway creation
+  # but if `false` is passed, it will stay as false (can be used to override a default option passed on gateway creation)
+  def connect(method,
+              path:,
+              body: nil,
+              json_body: true,
+              timeout: nil,
+              authorization_bearer: nil,
+              authorization_token_hash: nil)
+
+    timeout                  = timeout.nil? ? @timeout : timeout
+    authorization_bearer     = authorization_bearer.nil? ? @authorization_bearer : authorization_bearer
+    authorization_token_hash = authorization_token_hash.nil? ? @authorization_token_hash : authorization_token_hash
+
     connection.send(method, path) do |req|
 
-      req.options.timeout = timeout if timeout.present?
+      req.options.timeout          = timeout if timeout.present?
+      req.headers['Authorization'] = Faraday::Request::Authorization.header(:Bearer, authorization_bearer) if authorization_bearer.present?
+      req.headers['Authorization'] = Faraday::Request::Authorization.header(:Token, authorization_token_hash) if authorization_token_hash.present?
 
       unless body.nil?
         if json_body
@@ -172,7 +238,15 @@ class ArtirixDataModels::DataGateway
         Faraday.new(url: url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
           faraday.request :url_encoded # form-encode POST params
           faraday.response :logger # log requests to STDOUT
-          faraday.basic_auth(config.login, config.password) if basic_auth?
+
+          if basic_auth?
+            faraday.basic_auth(config.login, config.password)
+          elsif bearer_auth?
+            faraday.authorization :Bearer, config.bearer_token
+          elsif token_auth?
+            faraday.authorization :Token, config.token_hash
+          end
+
           faraday.adapter Faraday.default_adapter
         end
       end
@@ -190,6 +264,14 @@ class ArtirixDataModels::DataGateway
       def basic_auth?
         config.respond_to?(:login) && config.respond_to?(:password)
       end
+
+      def bearer_auth?
+        config.respond_to?(:bearer_token) && config.bearer_token.present?
+      end
+
+      def token_auth?
+        config.respond_to?(:token_hash) && config.token_hash.present?
+      end
     end
 
   end

data/lib/artirix_data_models/spec_support/gateway_mock.rb

@@ -12,25 +12,61 @@ def given_gateway_config(connection_url = nil)
 end
 
 
-def mock_gateway_response(response:, method:, path:, body: nil, json_body: true, timeout: nil, gateway: nil)
+def mock_gateway_response(response:,
+                          method:,
+                          path:,
+                          body: nil,
+                          json_body: true,
+                          timeout: nil,
+                          authorization_bearer: nil,
+                          authorization_token_hash: nil,
+                          gateway: nil)
   gateway ||= ArtirixDataModels::DAORegistry.gateway
-  allow(gateway).to receive(:perform).with(method, path: path, body: body, json_body: json_body, timeout: timeout).and_return response
+
+  params_hash = {
+    path:                     path,
+    body:                     body,
+    json_body:                json_body,
+    timeout:                  timeout,
+    authorization_bearer:     authorization_bearer,
+    authorization_token_hash: authorization_token_hash
+  }
+
+  allow(gateway).to receive(:perform).with(method, params_hash).and_return response
 
   # check with body already parsed
   unless body.nil?
     body = body.kind_of?(String) ? body : body.to_json
-    allow(gateway).to receive(:perform).with(method, path: path, body: body, json_body: json_body, timeout: timeout).and_return response
+    allow(gateway).to receive(:perform).with(method, params_hash.merge(body: body)).and_return response
   end
 end
 
-def mock_gateway_not_found_response(method:, path:, body: nil, json_body: true, timeout: nil, gateway: nil)
+def mock_gateway_not_found_response(method:,
+                                    path:,
+                                    body: nil,
+                                    json_body: true,
+                                    timeout: nil,
+                                    authorization_bearer: nil,
+                                    authorization_token_hash: nil,
+                                    gateway: nil)
+
   gateway ||= ArtirixDataModels::DAORegistry.gateway
-  allow(gateway).to receive(:perform).with(method, path: path, body: body, json_body: json_body, timeout: timeout).and_raise ArtirixDataModels::DataGateway::NotFound
+
+  params_hash = {
+    path:                     path,
+    body:                     body,
+    json_body:                json_body,
+    timeout:                  timeout,
+    authorization_bearer:     authorization_bearer,
+    authorization_token_hash: authorization_token_hash
+  }
+
+  allow(gateway).to receive(:perform).with(method, params_hash).and_raise ArtirixDataModels::DataGateway::NotFound
 
   # check with body already parsed
   unless body.nil?
     body = body.kind_of?(String) ? body : body.to_json
-    allow(gateway).to receive(:perform).with(method, path: path, body: body, json_body: json_body, timeout: timeout).and_raise ArtirixDataModels::DataGateway::NotFound
+    allow(gateway).to receive(:perform).with(method, params_hash.merge(body: body)).and_raise ArtirixDataModels::DataGateway::NotFound
   end
 end
 

data/lib/artirix_data_models/version.rb

@@ -1,3 +1,3 @@
 module ArtirixDataModels
-  VERSION = '0.16.0'
+  VERSION = '0.17.0'
 end

data/spec/artirix_data_models/gateways/data_gateway_spec.rb

@@ -1,6 +1,15 @@
 require 'spec_helper'
 
 RSpec.describe ArtirixDataModels::DataGateway, type: :model do
+  Given(:bearer) { 'MyBearerToken' }
+  Given(:bearer2) { 'OtherBearerToken' }
+
+  Given(:token_hash) { { a: '123', b: 'abc' } }
+  Given(:token_str) { Faraday::Request::Authorization.build_hash('Token', token_hash) }
+
+  Given(:token_hash2) { { x: 'some', y: 'whaat' } }
+  Given(:token_str2) { Faraday::Request::Authorization.build_hash('Token', token_hash2) }
+
   describe '.new' do
     context 'without connection' do
       Given(:connection_url) { 'http://example.com/other' }
@@ -30,6 +39,9 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
 
         SimpleConfig.for(:site) do
           group :data_gateway do
+            unset :bearer_token if set? :bearer_token
+            unset :token_hash if set? :token_hash
+
             set :url, url
             set :login, login
             set :password, password
@@ -41,6 +53,54 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
       Then { expect(gateway.connection.url_prefix.to_s).to eq(connection_url) }
       Then { expect(gateway.connection.headers).to have_key('Authorization') }
     end
+
+    context 'Bearer auth connection' do
+      Given(:connection_url) { 'http://example.com/other' }
+
+      Given do
+        u = connection_url
+        b = bearer
+
+        SimpleConfig.for(:site) do
+          group :data_gateway do
+            unset :login if set? :login
+            unset :password if set? :password
+            unset :token_hash if set? :token_hash
+
+            set :url, u
+            set :bearer_token, b
+          end
+        end
+      end
+
+      When(:gateway) { described_class.new }
+      Then { expect(gateway.connection.url_prefix.to_s).to eq(connection_url) }
+      Then { expect(gateway.connection.headers['Authorization']).to eq("Bearer #{bearer}") }
+    end
+
+    context 'Token auth connection' do
+      Given(:connection_url) { 'http://example.com/other' }
+
+      Given do
+        u = connection_url
+        t = token_hash
+
+        SimpleConfig.for(:site) do
+          group :data_gateway do
+            unset :login if set? :login
+            unset :password if set? :password
+            unset :bearer_token if set? :bearer_token
+
+            set :url, u
+            set :token_hash, t
+          end
+        end
+      end
+
+      When(:gateway) { described_class.new }
+      Then { expect(gateway.connection.url_prefix.to_s).to eq(connection_url) }
+      Then { expect(gateway.connection.headers['Authorization']).to eq(token_str) }
+    end
   end
 
   context 'requests with timeout' do
@@ -66,6 +126,177 @@ RSpec.describe ArtirixDataModels::DataGateway, type: :model do
     end
   end
 
+  context 'requests with token based auth' do
+    Given(:path) { '/somepath' }
+
+    Given(:connection_url) { 'http://example.com/other' }
+    Given do
+      c = connection_url
+      SimpleConfig.for(:site) do
+        group :data_gateway do
+          set :url, c
+        end
+      end
+    end
+
+    Given(:connection_stubs) { Faraday::Adapter::Test::Stubs.new }
+
+    Given(:connection) do
+      Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
+        faraday.request :url_encoded # form-encode without body only path params
+        faraday.response :logger # log requests to STDOUT
+        faraday.adapter :test, connection_stubs
+
+        faraday.authorization :Bearer, bearer
+      end
+    end
+
+    Given(:gateway) do
+      described_class.new connection: connection
+    end
+
+    Given do
+      # stub gets
+      connection_stubs.get(path, headers_bearer) do |env|
+        [200, {}, response_body_bearer.to_json]
+      end
+
+      connection_stubs.get(path, headers_bearer2) do |env|
+        [200, {}, response_body_bearer2.to_json]
+      end
+
+      connection_stubs.get(path, headers_token) do |env|
+        [200, {}, response_body_token.to_json]
+      end
+
+      connection_stubs.get(path, headers_token2) do |env|
+        [200, {}, response_body_token2.to_json]
+      end
+
+      connection_stubs.get(path, headers_empty) do |env|
+        [200, {}, response_body_empty.to_json]
+      end
+    end
+
+    Given(:headers_empty) { {} }
+    Given(:headers_bearer) { { 'Authorization' => "Bearer #{bearer}" } }
+    Given(:headers_bearer2) { { 'Authorization' => "Bearer #{bearer2}" } }
+    Given(:headers_token) { { 'Authorization' => token_str } }
+    Given(:headers_token2) { { 'Authorization' => token_str2 } }
+
+    Given(:response_body_empty) { { status: 'is empty' } }
+    Given(:response_body_bearer) { { status: 'with bearer' } }
+    Given(:response_body_bearer2) { { status: 'with bearer2' } }
+    Given(:response_body_token) { { status: 'with token' } }
+    Given(:response_body_token2) { { status: 'with token2' } }
+
+    context 'Bearer' do
+      context 'in config of connection' do
+        Given(:connection) do
+          Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
+            faraday.authorization :Bearer, bearer
+            faraday.request :url_encoded # form-encode without body only path params
+            faraday.response :logger # log requests to STDOUT
+            faraday.adapter :test, connection_stubs
+          end
+        end
+
+        describe 'normal use (uses the bearer)' do
+          Given(:gateway) do
+            described_class.new connection: connection
+          end
+
+          When(:result) { gateway.get path }
+          Then { result == response_body_bearer }
+        end
+      end
+
+      context 'not in config of connection' do
+        Given(:connection) do
+          Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
+            faraday.request :url_encoded # form-encode without body only path params
+            faraday.response :logger # log requests to STDOUT
+            faraday.adapter :test, connection_stubs
+          end
+        end
+
+        context 'passing on init' do
+          Given(:gateway) do
+            described_class.new connection: connection, authorization_bearer: bearer
+          end
+
+          describe 'normal use (uses the bearer)' do
+            When(:result) { gateway.get path }
+            Then { result == response_body_bearer }
+          end
+
+          describe 'overrides with other bearer (uses the other bearer)' do
+            When(:result) { gateway.get path, authorization_bearer: bearer2 }
+            Then { result == response_body_bearer2 }
+          end
+
+          describe 'overrides with false (uses no bearer)' do
+            When(:result) { gateway.get path, authorization_bearer: false }
+            Then { result == response_body_empty }
+          end
+        end
+      end
+    end
+
+    context 'Token' do
+      context 'in config of connection' do
+        Given(:connection) do
+          Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
+            faraday.authorization :Token, token_hash
+            faraday.request :url_encoded # form-encode without body only path params
+            faraday.response :logger # log requests to STDOUT
+            faraday.adapter :test, connection_stubs
+          end
+        end
+
+        describe 'normal use (uses the token)' do
+          Given(:gateway) do
+            described_class.new connection: connection
+          end
+
+          When(:result) { gateway.get path }
+          Then { result == response_body_token }
+        end
+      end
+
+      context 'not in config of connection' do
+        Given(:connection) do
+          Faraday.new(url: connection_url, request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
+            faraday.request :url_encoded # form-encode without body only path params
+            faraday.response :logger # log requests to STDOUT
+            faraday.adapter :test, connection_stubs
+          end
+        end
+
+        context 'passing on init' do
+          Given(:gateway) do
+            described_class.new connection: connection, authorization_token_hash: token_hash
+          end
+
+          describe 'normal use (uses the token)' do
+            When(:result) { gateway.get path }
+            Then { result == response_body_token }
+          end
+
+          describe 'overrides with other token (uses the other token)' do
+            When(:result) { gateway.get path, authorization_token_hash: token_hash2 }
+            Then { result == response_body_token2 }
+          end
+
+          describe 'overrides with false (uses no token)' do
+            When(:result) { gateway.get path, authorization_token_hash: false }
+            Then { result == response_body_empty }
+          end
+        end
+      end
+    end
+  end
+
   context 'requests' do
     Given(:connection_url) { 'http://example.com' }
     Given(:connection_stubs) { Faraday::Adapter::Test::Stubs.new }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: artirix_data_models
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-11 00:00:00.000000000 Z
+date: 2016-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport