setsuzoku 0.11.0 → 0.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36e5b7968d72649e85fed697caf9d4b04613faa1b69e347bc347712743ddb55a
-  data.tar.gz: 11b0433cee31db3ffb7ee39d36c3c31dd4bab600b238a57a51519770d3453eff
+  metadata.gz: cd0ca4436f63ee80c7411553690acc0600a3556842acda30c580767de4d5fefe
+  data.tar.gz: 9cdf81df738bc16aef812b6cc5f68cb7e26b5a3a1666dcbf214a79ac16e22f28
 SHA512:
-  metadata.gz: 27c41fe87bebe18b575359b471c3e7497292c5ba730b8698704352ad7f43f7a6d9824a8ee7d81c8d52e6d3dbb3247e7c4d3024b19cb1909c1e3bfc888fb0f823
-  data.tar.gz: 1352f256aacaeaa77d3565c5d14992bba7689717ea2c928485f3a4304b62b110db47b1c532ccb0266909f02719539c19ca8165c828973c4a8528ef8e74f23437
+  metadata.gz: 888f8ee20d1bc364d6a0b9ddd54ab2cdeb8c9e54078ea5bc36ef5193fac5d75ee7310492c55493fa4e6dae2975103b31e087ca6f23557bca2d52f22622d5a700
+  data.tar.gz: a07a89413cae6b20f159eec21cd37f90e73e80d8ee8b1d0522f5186b71aa587483145c29deaff231337a805fb5291ba3c45e17a364cab37e0123890982ffd218

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    setsuzoku (0.11.0)
+    setsuzoku (0.11.9)
       activesupport (~> 5.0)
       faraday (~> 0.11)
       httparty (~> 0.16.4)
@@ -57,7 +57,7 @@ GEM
     safe_yaml (1.0.5)
     sorbet (0.5.5675)
       sorbet-static (= 0.5.5675)
-    sorbet-runtime (0.5.5862)
+    sorbet-runtime (0.5.5878)
     sorbet-static (0.5.5675-universal-darwin-14)
     thread_safe (0.3.6)
     tzinfo (1.2.7)

data/lib/setsuzoku/api_strategy.rb

@@ -80,7 +80,7 @@ module Setsuzoku
       self.external_api_handler.call_external_api_wrapper(plugin: self.plugin, request: request, action_details: action_details) do
         begin
           # raise if the token is invalid and needs refreshed, but don't raise if we are trying to get a refresh token
-          raise Setsuzoku::Exception::InvalidAuthCredentials.new unless (request.action == :refresh_token || self.auth_strategy.auth_credential_valid?)
+          raise Setsuzoku::Exception::InvalidAuthCredentials.new unless (strategy == :auth || self.auth_strategy.auth_credential_valid?)
           raw_response = self.perform_external_call(request: request, action_details: action_details, **options)
           formatted_response = self.parse_response(response: raw_response, response_type: action_details[:actions][request.action][:response_type])
           success = true

data/lib/setsuzoku/credential.rb

@@ -14,6 +14,18 @@ module Setsuzoku
     sig { abstract.returns(Struct) }
     def self.stub_credential; end
 
+    # The status of the credential.
+    #
+    # @return [Hash] the status of the credential.
+    sig { abstract.returns(String) }
+    def status; end
+
+    # Setter for the status of the credential.
+    #
+    # @return [Hash] the status of the credential.
+    sig { abstract.params(val: T.nilable(String)).returns(String) }
+    def status=(val); end
+
     # A settings object for the credential.
     #
     # @return [Hash] the settings for the credential.

data/lib/setsuzoku/rspec/dynamic_spec_helper.rb

@@ -2,6 +2,8 @@
 
 require 'active_support/core_ext/class/subclasses'
 require 'active_support/inflector/methods'
+require 'faraday'
+
 module Setsuzoku
   module DynamicSpecHelper
 
@@ -150,20 +152,21 @@ module Setsuzoku
         stub.each do |action_name, props|
           props.each do |propz|
             plugin.api_strategy.current_action = action_name
-            default_headers = plugin.api_strategy.request_options(propz[:request_format])[:headers] || { 'Authorization' => 'Bearer stubbed_token', 'Content-Type' => "application/#{propz[:request_format]}" }
+            default_headers = plugin.api_strategy.request_options(propz[:request_format])[:headers] || { 'Content-Type' => "application/#{propz[:request_format]}" }
             if plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::BasicAuthStrategy)
               basic_auth = plugin.api_strategy.request_options(propz[:request_format])[:basic_auth]
               auth_header = { 'Authorization' => "Basic #{Base64.encode64("#{basic_auth[:username]}:#{basic_auth[:password]}").gsub("\n", '')}" }
-              default_headers.merge!(auth_header)
+            elsif plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::OAuthStrategy)
+              auth_header = { 'Authorization' => "Bearer #{plugin.api_strategy.request_options(propz[:request_format])[:token]}" }
             end
+            default_headers.merge!(auth_header) if auth_header
             headers = propz[:headers] ? [propz[:headers]] : [default_headers]
             stub_directory ||= "#{plugin.class.plugin_namespace}/#{provider}"
+
             headers.each do |header|
-              header = {
-                  'Accept'=>'*/*',
-                  'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                  'User-Agent'=>'Ruby'
-              }.merge(header.deep_stringify_keys)
+              header = Faraday.new.headers
+                        .merge({'Accept'=>'*/*','Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'})
+                        .merge(header.deep_stringify_keys)
 
               if propz[:stub_data]
                 # we have specified specific stub data for this action

data/lib/setsuzoku/service/web_service/api_strategies/rest_strategy.rb

@@ -33,7 +33,7 @@ module Setsuzoku
           #   media_type - 'json'
           #
           # @return [Hash] the parsed response object.
-          sig { override.params(request: T.untyped, action_details: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(Faraday::Response) }
+          sig { override.params(request: RestAPIRequest, action_details: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(Faraday::Response) }
           def perform_external_call(request:, action_details:, **options)
             request_properties = self.get_request_properties(action_name: request.action, action_details: action_details, req_params: request.body)
             request_options = self.request_options(request_properties[:request_format], action_details[:actions][request.action])
@@ -43,11 +43,14 @@ module Setsuzoku
             @faraday = Faraday.new(url: request_properties[:formatted_full_url], request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
               faraday.request(:multipart) if options[:attachments].present?
               faraday.request(:url_encoded)
-              # faraday.basic_auth(request_options[:basic_auth][:username], request_options[:basic_auth][:password]) if request_options[:basic_auth]
-              faraday.request(:basic_auth, request_options[:basic_auth][:username], request_options[:basic_auth][:password]) if request_options[:basic_auth]
-              # faraday.response request_properties[:response_format] if request_properties[:response_format]
-              faraday.authorization(:Bearer, request_properties[:token]) if request_properties[:token]
-              # request_options[:headers][:Authorization].prepend('Bearer ') if request_options[:headers][:Authorization]
+              #TODO: change these to faraday = self.auth_strategy.set_authorization!(request: faraday)
+              unless request.without_headers
+                if request_options[:token]
+                  faraday.authorization(:Bearer, request_options[:token])
+                elsif request_options[:basic_auth]
+                  faraday.request(:basic_auth, request_options[:basic_auth][:username], request_options[:basic_auth][:password])
+                end
+              end
               faraday.adapter Faraday.default_adapter
             end
 
@@ -60,7 +63,11 @@ module Setsuzoku
                 req.body = payload
               end
             else
-              @faraday.headers = request_options[:headers] if request_options[:headers]
+              if request.without_headers
+                @faraday.headers = {}
+              elsif request_options[:headers]
+                @faraday.headers = (@faraday.headers || {}).merge(request_options[:headers])
+              end
               resp = @faraday.send(request_properties[:request_method], request_properties[:formatted_full_url], full_request)
             end
             resp
@@ -81,7 +88,6 @@ module Setsuzoku
             request_method = request_method.downcase.to_sym
             request_format = action[:request_type]
             response_format = action[:response_type]
-            token = action[:token]
             stub_data = action[:stub_data] if for_stub
             full_url = url + endpoint
             formatted_full_url, req_params = self.replace_dynamic_vars(full_url: full_url, req_params: req_params)
@@ -93,7 +99,6 @@ module Setsuzoku
                 formatted_full_url: formatted_full_url,
                 req_params: req_params,
                 stub_data: stub_data,
-                token: token
             }
           end
 

data/lib/setsuzoku/service/web_service/auth_strategies/o_auth_strategy.rb

@@ -31,9 +31,7 @@ module Setsuzoku
           sig { override.returns(T::Hash[Symbol, T.untyped]) }
           def auth_headers
             {
-                headers: {
-                    'Authorization': "Bearer #{self.credential.token}"
-                }
+              token: self.credential.token
             }
           end
 
@@ -73,7 +71,7 @@ module Setsuzoku
           # @return [Boolean] true if the token is invalid.
           sig { returns(T::Boolean) }
           def token_is_invalid?
-            active = self.credential.respond_to?(:"status") ? self.credential.status != 'disabled' : true
+            active = self.credential.status != 'disabled'
             active && !self.credential.expires_on.blank? &&
                 !self.credential.refresh_token.blank? &&
                 (self.credential.expires_on < refresh_before_expiration_time)
@@ -112,38 +110,32 @@ module Setsuzoku
           sig { params(body: T::Hash[Symbol, String], action: Symbol).void }
           def get_token!(body, action)
             success = false
-            request = self.api_strategy.request_class.new(action: action, body: body)
+            request = self.api_strategy.request_class.new(action: action, body: body, without_headers: true)
 
             resp = self.api_strategy.call_external_api(request: request, strategy: :auth)
 
+            attrs = {}
             if resp.data && resp.data[:access_token]
-              self.credential.status = 'active' if self.credential.respond_to?(:"status=")
-              self.credential.token = resp.data[:access_token]
-              self.credential.refresh_token = resp.data[:refresh_token] if resp.data.key?(:refresh_token)
-              self.credential.expires_on = if resp.data[:expires_in]
-                                             resp.data[:expires_in].to_i.seconds.from_now
-                                           # elsif resp.data[:issued_at] && self.class.token_valid_for
-                                           #   Time.at(resp.data[:issued_at].to_i / 1000) + self.class.token_valid_for
-                                           end
-
-              self.plugin.set_credential_fields!(resp) if self.plugin.respond_to?(:set_credential_fields!)
-
-              #TODO: figure out a better way to do this  when we add other integrations...
-              #
-              # if self.is_a?(FacebookIntegration)
-              #   resp = self.exchange_for_long_lived_token
-              #   if resp && resp.data['access_token']
-              #     self.token = resp.data['access_token']
-              #     self.refresh_token = resp.data['access_token']
-              #     self.expires_on = 59.days.from_now
-              #   end
-              # end
+              attrs[:status] = 'active'
+              attrs[:token] = resp.data[:access_token]
+              attrs[:refresh_token] = resp.data[:refresh_token] if resp.data.key?(:refresh_token)
+              attrs[:expires_on] = resp.data[:expires_in].to_i.seconds.from_now if resp.data[:expires_in]
+
+              plugin_attrs = self.plugin.credential_fields_to_update(resp) if self.plugin.respond_to?(:credential_fields_to_update)
+              attrs.merge!(plugin_attrs)
             else
-              self.credential.status = 'error' if self.credential.respond_to?(:"status=")
+              attrs[:status] = 'error'
             end
 
-            if self.credential.respond_to?(:"save")
-              self.credential.save && resp.success
+            # Only save Setsuzoku known fields, and any additional attributes the plugin specifies
+            # in credential_fields_to_update.
+            if self.credential.respond_to?(:"update_columns")
+              # we issue an update_columns instead of a save/update_attributes
+              # so as to only mutate these attributes
+              # and not any other fields that may have been set for the credential
+              save = self.credential.update_columns(attrs)
+              self.credential.touch if save && self.credential.respond_to?(:"touch")
+              save && resp.success
             else
               resp.success
             end

data/lib/setsuzoku/service/web_service/credentials/basic_auth_credential.rb

@@ -42,8 +42,8 @@ module Setsuzoku
           # @return [Struct] a stubbed basic_auth_credential-like struct.
           sig { returns(Struct) }
           def self.stub_credential
-            s = Struct.new(:username, :password)
-            s.new('stubbed_username', 'stubbed_password')
+            s = Struct.new(:status, :settings, :username, :password)
+            s.new('active', {}, 'stubbed_username', 'stubbed_password')
           end
         end
       end

data/lib/setsuzoku/service/web_service/credentials/o_auth_credential.rb

@@ -73,8 +73,8 @@ module Setsuzoku
           # @return [Struct] a stubbed o_auth_credential-like struct.
           sig { returns(Struct) }
           def self.stub_credential
-            s = Struct.new(:client_id, :client_secret, :redirect_url, :token, :refresh_token, :expires_on, :settings)
-            s.new('stubbed_client_id', 'stubbed_client_secret', 'stubbed_redirect_url', 'stubbed_token', 'refresh_token', (Time.now + 30.days), 'extension': 'test')
+            s = Struct.new(:status, :settings, :client_id, :client_secret, :redirect_url, :token, :refresh_token, :expires_on)
+            s.new('active', {'extension': 'test'}, 'stubbed_client_id', 'stubbed_client_secret', 'stubbed_redirect_url', 'stubbed_token', 'refresh_token', (Time.now + 30.days))
           end
         end
       end

data/lib/setsuzoku/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Setsuzoku
-  VERSION = '0.11.0'
+  VERSION = '0.11.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: setsuzoku
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.9
 platform: ruby
 authors:
 - Luke Stadtler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-11 00:00:00.000000000 Z
+date: 2020-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler