ribbon-intercom 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc502869702b01539172c77ab6f12fea946251f1
-  data.tar.gz: 15672af11bd53026f9613035366b5d3b9fe683a5
+  metadata.gz: 977c89158ba0646225543c4b65b86fc9db5663b4
+  data.tar.gz: 9482ff868c0d2e7974cbf08e329c8e18eb85b21a
 SHA512:
-  metadata.gz: 110c7d7b8f7b5f19ac51eaad0d85f7f8ff19f05bbcf8a10aa12b53ec6d5d6ca7887d1034a573de8179bb466f9025b5bc7c0ff5a7dcfbbc5384759f20b72afb9b
-  data.tar.gz: 44f4a6fbb476e2f80ce65250488ea50405908e6f1ccb3410923b4c4f35e6bab5e74b3545cd00cdd61830d5ee09c23e5aca08737b2a5c83ec260331278037d15e
+  metadata.gz: 6ac6cdc49ae1e738c21ad1cdc91a1d02340c7d04d35fe50a3eab1d9ca08e767366b3725b828b21f2e29b132a5bec70668683b337e80096e5b02e1c8f4063650f
+  data.tar.gz: ed7da55ea2c9dca75e712cf83f691977ed3aec4bb01f6ed0f5dcdf6999320d59b6dd091b954107f19cdaa7bc20985882c1293177e74f5f2e281720ca0080e5f0

data/lib/ribbon/intercom/client/mock_sdk.rb

@@ -0,0 +1,13 @@
+module Ribbon::Intercom
+  class Client
+    class MockSDK < SDK
+      def initialize(service)
+        super(Adapters::MockAdapter.new(service))
+      end
+
+      def with_permissions(*perms, &block)
+        adapter.with_permissions(*perms, &block)
+      end
+    end # MockSDK
+  end # Client
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/adapter/response.rb

@@ -0,0 +1,38 @@
+module Ribbon::Intercom
+  class Client::SDK::Adapters::Adapter
+    class Response < Rack::Response
+      attr_reader :method_name
+
+      def initialize(body, status, headers, method_name)
+        super(body, status, headers)
+        @method_name = method_name.to_sym
+      end
+
+      def missing_permissions
+        @__missing_permissions ||= _intercom_permissions_missing
+      end
+
+      def body
+        super.join
+      end
+
+      ##
+      # Decode the response body received from the service.
+      def retval
+        @__retval ||= Marshal.load(Base64.strict_decode64(body)) unless body.empty?
+      end
+
+      private
+
+      def _intercom_permissions_missing
+        key = _intercom_permissions_missing_header
+        headers[key] && headers[key].split(',').to_set
+      end
+
+      def _intercom_permissions_missing_header
+        missing_keys = ['X-Intercom-Permissions-Missing', :x_intercom_permissions_missing]
+        missing_keys.detect { |key| headers.key?(key) }
+      end
+    end # Response
+  end # Client::SDK::Adapters::Adapter
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/adapter.rb

@@ -0,0 +1,51 @@
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class Adapter
+      autoload(:Response, 'ribbon/intercom/client/sdk/adapters/adapter/response')
+
+      def initialize(*args)
+        connect(*args)
+      end
+
+      ##
+      # Call the method on the service.
+      def call(method_name, *args)
+        call!(method_name, _encode_args(*args)).tap { |response|
+          raise TypeError, "call! should return an Adapter::Response" unless response.is_a?(Response)
+          raise "response should have correct method name" unless response.method_name == method_name.to_sym
+        }
+      end
+
+      def headers(h={})
+        (@__headers ||= {}).merge!(h)
+      end
+
+      ##
+      # Connect to a service. The specific arguments depend on the Adapter
+      # subclass.
+      def connect(*args)
+        raise NotImplementedError
+      end
+
+      ##
+      # Returns whether or not the Adapter is connected to a service.
+      def connected?
+        raise NotImplementedError
+      end
+
+      ##
+      # Actually call the method on the service. Should return an Adapter::Response object.
+      def call!(method_name, *args)
+        raise NotImplementedError
+      end
+
+      private
+
+      ##
+      # Encode the arguments for transmission to the service.
+      def _encode_args(*args)
+        Base64.strict_encode64(Marshal.dump(Utils.sanitize(args)))
+      end
+    end # Adapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/http_adapter/connection.rb

@@ -0,0 +1,34 @@
+require 'net/http'
+require 'openssl'
+require 'uri'
+
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class HttpAdapter::Connection
+      attr_reader :url
+
+      def initialize(url, token, secret)
+        @url = url.is_a?(String) ? URI(url) : url
+
+        @_client = Net::HTTP.new(url.hostname, url.port)
+        @_client.use_ssl = url.is_a?(URI::HTTPS)
+        @_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        @_client.cert_store = OpenSSL::X509::Store.new.tap { |s| s.set_default_paths }
+
+        @_headers = {
+          'Authorization' => "Basic #{Base64.strict_encode64("#{token}:#{secret}")}"
+        }
+      end
+
+      def put(params={})
+        @_client.put(url.request_uri, params[:body], _prepare_headers(params[:headers]).merge(@_headers))
+      end
+
+      private
+
+      def _prepare_headers(headers)
+        Hash[(headers || {}).map { |k, v| [k.to_s, v.to_s] }]
+      end
+    end # HttpAdapter::Connection
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/http_adapter.rb

@@ -0,0 +1,26 @@
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class HttpAdapter < Adapter
+      autoload(:Connection, 'ribbon/intercom/client/sdk/adapters/http_adapter/connection')
+
+      attr_reader :connection
+
+      def connect(*args)
+        @connection = Connection.new(*args)
+      end
+
+      def connected?
+        !!connection
+      end
+
+      def call!(method_name, encoded_args)
+        response = connection.put(
+          headers: headers.merge("X-Intercom-Method" => method_name),
+          body:    encoded_args
+        )
+
+        Adapter::Response.new(response.body, response.code.to_i, response, method_name)
+      end
+    end # HttpAdapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/local_adapter.rb

@@ -0,0 +1,54 @@
+require 'base64'
+
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class LocalAdapter < Adapter
+      attr_reader :service
+      attr_accessor :channel_token
+      attr_accessor :channel_secret
+
+      def connect(service, params={})
+        case service
+        when Service
+          @service = service
+        else
+          raise ArgumentError, "Expected a service, got: #{service.inspect}"
+        end
+
+        @channel_token = params[:channel_token]
+        @channel_secret = params[:channel_secret]
+      end
+
+      def connected?(*args)
+        !!service
+      end
+
+      def call!(method_name, encoded_args)
+        response = service.call(
+          _http_headers.merge(
+            'HTTP_AUTHORIZATION'     => _http_auth,
+            'HTTP_X_INTERCOM_METHOD' => method_name.to_s,
+            'REQUEST_METHOD'         => 'PUT',
+            'rack.input'             => StringIO.new(encoded_args)
+          )
+        )
+
+        Response.new(response[2], response[0], response[1], method_name)
+      end
+
+      private
+
+      def _http_auth
+        "Basic #{Base64.strict_encode64("#{channel_token}:#{channel_secret}")}"
+      end
+
+      def _http_headers
+        Hash[headers.map { |name, value| [_header_to_http(name), value] }]
+      end
+
+      def _header_to_http(name)
+        name.to_s.upcase.gsub('-', '_')
+      end
+    end # MockAdapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters/mock_adapter.rb

@@ -0,0 +1,40 @@
+module Ribbon::Intercom
+  module Client::SDK::Adapters
+    class MockAdapter < LocalAdapter
+      attr_reader :store
+
+      def connect(service)
+        if service.is_a?(Class) && service < Service
+          service = service.new(store: Service::Channel::Stores::MockStore.new)
+        end
+
+        unless service.is_a?(Service)
+          raise ArgumentError, "Expected a service, got: #{service.inspect}"
+        end
+
+        unless service.store.is_a?(Service::Channel::Stores::MockStore)
+          raise ArgumentError, "Expected service to have a MockStore, got: #{service.store.inspect}"
+        end
+
+        super(service)
+        @store = service.store
+      end
+
+      def with_permissions(*perms, &block)
+        channel = store.open_channel(name: 'mock channel', may: perms)
+        secret = channel.rotate_secret!
+        with_channel(channel.token, secret, &block)
+      ensure
+        channel.close
+      end
+
+      def with_channel(token, secret)
+        token_prv, secret_prv = self.channel_token, self.channel_secret
+        self.channel_token, self.channel_secret = token, secret
+        yield
+      ensure
+        self.channel_token, self.channel_secret = token_prv, secret_prv
+      end
+    end # MockAdapter
+  end # Client::SDK::Adapters
+end # Ribbon::Intercom

data/lib/ribbon/intercom/client/sdk/adapters.rb

@@ -0,0 +1,10 @@
+module Ribbon::Intercom
+  class Client::SDK
+    module Adapters
+      autoload(:Adapter,     'ribbon/intercom/client/sdk/adapters/adapter')
+      autoload(:HttpAdapter, 'ribbon/intercom/client/sdk/adapters/http_adapter')
+      autoload(:LocalAdapter, 'ribbon/intercom/client/sdk/adapters/local_adapter')
+      autoload(:MockAdapter, 'ribbon/intercom/client/sdk/adapters/mock_adapter')
+    end
+  end
+end

data/lib/ribbon/intercom/client/sdk.rb

@@ -1,49 +1,94 @@
+require 'base64'
+
 module Ribbon::Intercom
   class Client
     class SDK
-      autoload(:Connection, 'ribbon/intercom/client/sdk/connection')
-      autoload(:Response, 'ribbon/intercom/client/sdk/response')
+      autoload(:Adapters, 'ribbon/intercom/client/sdk/adapters')
+
+      include Utils::Mixins::MockSafe
 
-      attr_reader :connection
+      attr_reader :adapter
 
       def initialize(*args)
-        connect(*args)
+        case args.first
+        when Adapters::Adapter
+          @adapter = args.first
+        else
+          @adapter = Adapters::HttpAdapter.new(*args)
+        end
+      end
+
+      def headers(h={})
+        adapter.headers(h)
       end
 
       def connect(*args)
-        @connection = Connection.new(*args)
+        adapter.connect(*args)
       end
 
       def connected?
-        !!connection
+        adapter.connected?
       end
 
-      def method_missing(meth, *args, &block)
-        _send_request(meth, *args)
+      ##
+      # Calls the method on the adapter returning the Adapter::Response.
+      #
+      # Intended to be called by Package.
+      def call(method_name, *args)
+        _process_response(adapter.call(method_name, *args))
       end
 
       private
 
-      def _send_request(method_name, *args)
-        response = connection.put("", method_name, args)
+      ##
+      # Simulates calling the remote method as if it were a local method.
+      #
+      # Intended to be called by end-users.
+      def method_missing(meth, *args, &block)
+        call(meth, *args).retval
+      end
 
-        if response.success?
-          response.body
-        else
-          case response.code
-          when 401
-            raise Errors::AuthenticationError, request.body
-          when 403
-            raise Errors::MissingPermissionsError, response.missing_permissions.to_a.join(', ')
-          when 404
-            raise Errors::InvalidMethodError, "#{method_name} is not a valid method"
-          when 500
-            raise Errors::ServerError, response.body
-          else
-            raise Errors::RequestFailureError, response.body
+      ##
+      # Process an Adapter::Response object returned by Adapter#call.
+      def _process_response(response)
+        _handle_response_error(response) unless response.successful?
+
+        _init_packages(response.retval)
+        response
+      end
+
+      ##
+      # Raises an error depending on what went wrong.
+      def _handle_response_error(response)
+        raise 'called for successful response' if response.successful?
+
+        encoded_error = response.headers['X-Intercom-Error']
+
+        if encoded_error && !encoded_error.empty?
+          begin
+            decoded_error = Base64.strict_decode64(encoded_error)
+            error = Marshal.load(decoded_error)
+          rescue
+            error = Errors::ServerError.new('unknown server error')
           end
         end
+
+        raise error || Errors::ServerError.new('unexpected server error')
+      end # _handle_response
+
+      ##
+      # Walks the object and initializes all packages (i.e., sets them up to be
+      # accessed by the end-user on the client).
+      def _init_packages(object)
+        Utils.walk(object) { |object|
+          if object.is_a?(Package)
+            object.sdk = dup
+            object.mock_safe! if mock_safe?
+          end
+
+          object
+        }
       end
-    end # Client
-  end # SDK
+    end # SDK
+  end # Client
 end # Ribbon::Intercom

data/lib/ribbon/intercom/client.rb

@@ -3,6 +3,7 @@ require 'ribbon/config'
 module Ribbon::Intercom
   class Client
     autoload(:SDK, 'ribbon/intercom/client/sdk')
+    autoload(:MockSDK, 'ribbon/intercom/client/mock_sdk')
 
     def config(&block)
       (@__config ||= Ribbon::Config.new).tap { |config|
@@ -16,16 +17,43 @@ module Ribbon::Intercom
       _load_sdk(handle)
     end
 
-    def _load_sdk(handle, url=nil, token=nil, secret=nil)
-      raise Errors::NoRemotesCreatedError unless config.remote?
+    ##
+    # Return a mock safe version of this client.
+    def mock_safe
+      dup.tap { |client|
+        client.preload_sdks
 
-      (@_sdk_instances ||= Hash.new { |hash, key|
-        if (remote = config.remote.select { |r| r.first == key }.last)
-          # Get the last remote if there are duplicates
-          config = remote.last
+        # Make SDK instances mock safe
+        client.sdk_instances = Hash[
+          client.sdk_instances.map { |service, sdk| [service, sdk.mock_safe] }
+        ]
+      }
+    end
+
+    def preload_sdks
+      if config.service?
+        config.service.each { |name, *args|
+          _load_sdk(name)
+        }
+      end
+    end
+
+    protected
+
+    attr_accessor :sdk_instances
+
+    private
+
+    def _load_sdk(handle)
+      raise Errors::ServiceNotDefinedError unless config.service?
+
+      (self.sdk_instances ||= Hash.new { |hash, key|
+        # Get the last service if there are duplicates
+        if (service_def = config.service.select { |r| r.first == key }.last)
+          name, config = service_def
           hash[key] = SDK.new(config[:url], config[:token], config[:secret])
         else
-          raise Errors::RemoteNotFoundError
+          raise Errors::ServiceNotDefinedError
         end
       })[handle.to_sym]
     end

data/lib/ribbon/intercom/errors.rb

@@ -2,14 +2,44 @@ module Ribbon::Intercom
   module Errors
     class Error < StandardError; end
 
+    #############
+    # Http Errors
+    class HttpError < Error; end
+
+    ##
+    # Request Errors
+
+    # 400 Error
+    class RequestError < HttpError; end
+    class UnsafeArgumentError < RequestError; end
+    class InvalidSubjectSignatureError < RequestError; end
+
+    # 401 Error
+    class AuthenticationError < RequestError; end
+
+    # 403 Error
+    class ForbiddenError < RequestError; end
+    class InsufficientPermissionsError < ForbiddenError; end
+
+    # 404 Not Found
+    class NotFoundError < RequestError; end
+    class InvalidMethodError < NotFoundError; end
+
+    # 405 Method Not Allowed
+    class MethodNotAllowedError < RequestError; end
+
+    ##
+    # Server Errors
+
+    # 500 Error
+    class ServerError < HttpError; end
+    class UnsafeResponseError < ServerError; end
+
     # General Errors
-    class MissingPermissionsError < Error; end
-    class ServerError < Error; end
     class UnsafeValueError < Error; end
 
     # Intercom Errors
-    class RemoteNotFoundError < Error; end
-    class NoRemotesCreatedError < Error; end
+    class ServiceNotDefinedError < Error; end
 
     # Service Errors
     class NoPermissionsError < Error; end
@@ -22,8 +52,6 @@ module Ribbon::Intercom
 
     # SDK Errors
     class RequestFailureError < Error; end
-    class InvalidMethodError < Error; end
-    class AuthenticationError < Error; end
 
     # Channel Errors
     class ChannelNameMissingError < Error; end

data/lib/ribbon/intercom/package.rb

@@ -0,0 +1,64 @@
+require 'base64'
+
+module Ribbon::Intercom
+  class Package
+    include Utils::Mixins::MockSafe
+
+    attr_reader :sdk
+
+    def initialize(subject_data=nil, data=nil)
+      self._subject_data = subject_data
+      @_data = data
+    end
+
+    def sdk=(sdk)
+      _set_sdk_headers(sdk)
+      @sdk = sdk
+    end
+
+    protected
+
+    def _subject_data=(data)
+      @_subject_data = data
+      _set_sdk_headers
+    end
+
+    private
+
+    def method_missing(meth, *args, &block)
+      if @_data && @_data.key?(meth)
+        @_data[meth]
+      elsif sdk
+        _process_response(sdk.call(meth, *args))
+      else
+        super
+      end
+    end
+
+    def marshal_dump
+      [@_subject_data, @_data]
+    end
+
+    def marshal_load(array)
+      self._subject_data = array[0]
+      @_data = array[1]
+
+    end
+
+    def _set_sdk_headers(sdk=sdk)
+      sdk.headers('X-Intercom-Subject' => @_subject_data) if sdk
+    end
+
+    def _process_response(response)
+      self._subject_data = response.headers['X-Intercom-Subject']
+      @_data = _retrieve_data_from_response(response)
+
+      response.retval
+    end
+
+    def _retrieve_data_from_response(response)
+      encoded_data = response.headers['X-Intercom-Package-Data']
+      encoded_data && Marshal.load(Base64.strict_decode64(encoded_data))
+    end
+  end # Package
+end # Ribbon::Intercom

data/lib/ribbon/intercom/packageable/mixin.rb

@@ -0,0 +1,35 @@
+require 'set'
+
+module Ribbon::Intercom
+  class Packageable
+    module Mixin
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        def package_with(*args)
+          args.map { |m| _package_with_methods << m.to_sym }
+        end
+
+        def _package_with_methods
+          @__package_with_methods ||= [].to_set
+        end
+      end # ClassMethods
+
+      ##
+      # Returns the package data for the instance as a hash.
+      def package_data
+        Utils.sanitize(
+          self.class._package_with_methods.map { |meth| [meth, public_send(meth)] }.to_h
+        )
+      end
+
+      def encoded_package_data
+        Base64.strict_encode64(Marshal.dump(package_data))
+      end
+    end # Mixin
+  end # Service::Subject
+end # Ribbon::Intercom

data/lib/ribbon/intercom/packageable.rb

@@ -0,0 +1,6 @@
+module Ribbon::Intercom
+  class Packageable
+    autoload(:Mixin, 'ribbon/intercom/packageable/mixin')
+    include Mixin
+  end # Packageable
+end # Ribbon::Intercom

data/lib/ribbon/intercom/service/channel/stores/mock_store.rb

@@ -0,0 +1,40 @@
+module Ribbon::Intercom
+  class Service
+    module Channel::Stores
+      class MockStore < Store
+        def channels
+          @__channels ||= {}
+        end
+
+        def lock
+          @__lock ||= Mutex.new
+        end
+
+        def token_exists?(token)
+          channels.key?(token)
+        end
+
+        def lookup_channel(token)
+          channels[token]
+        end
+
+        def persist(channel)
+          raise Errors::InvalidChannelError, channel.inspect unless channel.is_a?(Channel)
+          channels[channel.token] = channel
+        end
+
+        def delete(channel)
+          raise Errors::InvalidChannelError, channel.inspect unless channel.is_a?(Channel)
+          channels.delete(channel.token)
+          nil
+        end
+
+        def with_lock(channel, &block)
+          # This is a global lock, not a per-channel lock, but this store is only
+          # for testing so let's KISS.
+          lock.synchronize(&block)
+        end
+      end # RedisStore
+    end # Channel::Stores
+  end # Service
+end # Ribbon::Intercom