routemaster-client 2.1.0 → 3.0.0

data/routemaster/client/backends/sidekiq.rb

@@ -1,24 +1,33 @@
 require 'sidekiq'
+require 'forwardable'
 require 'routemaster/client/backends/sidekiq/worker'
+require 'routemaster/client/backends/sidekiq/configuration'
 
 module Routemaster
-  class Client
+  module Client
     module Backends
       class Sidekiq
-        @queue = :realtime
-
         class << self
-          def configure(options)
-            new(options)
+          extend Forwardable
+
+          attr_reader :options
+
+          def configure
+            self.tap do
+              Configuration.configure do |c|
+                yield c
+              end
+              @options = {'class' => Worker}.merge Configuration.sidekiq_options
+            end
           end
-        end
 
-        def initialize(options)
-          @_options = options
-        end
+          def send_event(*args)
+            opts = @options.merge('args' => args)
+            ::Sidekiq::Client.push opts
 
-        def send_event(event, topic, callback, timestamp = nil)
-          Worker.perform_async(event, topic, callback, timestamp, @_options)
+            # The push will throw an exception if there is a problem
+            true
+          end
         end
       end
     end

data/routemaster/client/backends/sidekiq/configuration.rb

@@ -0,0 +1,48 @@
+module Routemaster
+  module Client
+    module Backends
+      class Sidekiq
+        class Configuration
+          class << self
+
+            def configure
+              yield self
+            end
+
+            def queue=(value)
+              _sidekiq_options['queue'] = _stringify_symbol(value)
+            end
+
+            def backtrace=(value)
+              _sidekiq_options['backtrace'] = _stringify_symbol(value)
+            end
+
+            def retry=(value)
+              _sidekiq_options['retry'] = _stringify_symbol(value)
+            end
+
+            def pool=(value)
+              _sidekiq_options['pool'] = _stringify_symbol(value)
+            end
+
+            def sidekiq_options
+              _sidekiq_options.clone
+            end
+
+            private
+
+            attr_writer :sidekiq_options
+
+            def _sidekiq_options
+              @_sidekiq_options ||= {}
+            end
+
+            def _stringify_symbol(value)
+              value.is_a?(Symbol) ? value.to_s : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/routemaster/client/backends/sidekiq/worker.rb

@@ -1,22 +1,17 @@
 require 'routemaster/client/connection'
 
 module Routemaster
-  class Client
+  module Client
     module Backends
       class Sidekiq
         class Worker
           include ::Sidekiq::Worker
+          extend Forwardable
 
-          def perform(event, topic, callback, timestamp, options)
-            conn = Routemaster::Client::Connection.new(_symbolize_keys(options))
-            conn.send_event(event, topic, callback, timestamp)
-          end
+          def_delegator :'Routemaster::Client::Connection', :send_event
+          alias :perform :send_event
 
-          private
-
-          def _symbolize_keys(hash)
-            Hash[hash.map{|(k,v)| [k.to_sym,v]}]
-          end
+          private :send_event
         end
       end
     end

data/routemaster/client/backends/synchronous.rb

@@ -1,22 +1,12 @@
 require 'routemaster/client/connection'
 
 module Routemaster
-  class Client
+  module Client
     module Backends
       class Synchronous
-
         class << self
-          def configure(options)
-            new(options)
-          end
-        end
-
-        def initialize(options)
-          @conn = Routemaster::Client::Connection.new(options)
-        end
-
-        def send_event(event, topic, callback, timestamp = nil)
-          @conn.send_event(event, topic, callback, timestamp)
+          extend Forwardable
+          def_delegator :'Routemaster::Client::Connection', :send_event
         end
       end
     end

data/routemaster/client/configuration.rb

@@ -0,0 +1,70 @@
+require 'routemaster/client/assertion_helpers'
+require 'routemaster/client/errors'
+require 'routemaster/client/backends/missing_asynchronous'
+
+module Routemaster
+  module Client
+    class Configuration
+      class << self
+        include AssertionHelpers
+
+        DEFAULT_TIMEOUT = 5
+        DEFAULT_LAZY = false
+        DEFAULT_VERIFY_SSL = true
+
+        attr_accessor :url, :uuid, :timeout, :async_backend, :lazy, :verify_ssl
+
+        def configure
+          yield self
+          _validate_all_options!
+        end
+
+        private
+
+        def _validate_all_options!
+          _assert_present! url: url, uuid: uuid
+          _assert_valid_url!(url)
+          _assert_valid_uuid!(uuid)
+          timeout ? _assert_valid_timeout!(timeout) : self.timeout = DEFAULT_TIMEOUT
+
+          lazy.nil? ?  self.lazy = DEFAULT_LAZY : _assert_boolean!(lazy: lazy)
+          verify_ssl.nil? ? self.verify_ssl = DEFAULT_VERIFY_SSL : _assert_boolean!(verify_ssl: verify_ssl)
+          self.async_backend ||= Backends::MissingAsynchronous
+        end
+
+        def _assert_valid_url!(url)
+          assert_valid_url_throwing_error!(url, InvalidAttributeError)
+        end
+
+        def _assert_valid_uuid!(uuid)
+          raise MissingAttributeError, "uuid is required" unless uuid
+          unless  uuid =~ /^[a-z0-9_-]{1,64}$/
+            message =  "uuid '#{uuid}' is invalid, must only contain alphanumeric characters " +
+            "plus _ and - and be 1 to 64 characters"
+            raise InvalidAttributeError, message
+          end
+        end
+
+        def _assert_valid_timeout!(timeout)
+          unless (0..3_600_000).include? timeout
+            raise InvalidAttributeError, "timeout '#{timeout}' is invalid, must be an integer between 0 and 3,600,000"
+          end
+        end
+
+        def _assert_boolean!(**kwargs)
+          kwargs.each do |name, value|
+            unless [true, false].include? value
+              raise InvalidAttributeError, "#{name} '#{value}' is invalid, must be a boolean value: true or false"
+            end
+          end
+        end
+
+        def _assert_present!(**kwargs)
+          kwargs.each do |name, value|
+            raise MissingAttributeError, "#{name} is required" unless value
+          end
+        end
+      end
+    end
+  end
+end

data/routemaster/client/connection.rb

@@ -1,73 +1,72 @@
-require 'forwardable'
-
-# Internal class used by Routemaster::Client
+require 'routemaster/client/configuration'
 
 module Routemaster
-  class Client
-    class Connection
+  module Client
+    module Connection
+      class << self
+        extend Forwardable
 
-      def initialize(options)
-        @_url = options[:url]
-        @_uuid = options[:uuid]
-        @_timeout = options.fetch(:timeout, 1)
-        @_verify_ssl = options.fetch(:verify_ssl, true)
-      end
+        def post(path, &block)
+          http(:post, path, &block)
+        end
 
-      def http(method, path, &block)
-        _conn.send(method, path, &block)
-      end
+        def get(path, &block)
+          http(:get, path, &block)
+        end
 
-      def post(path, &block)
-        http(:post, path, &block)
-      end
+        def delete(path, &block)
+          http(:delete, path, &block)
+        end
 
-      def get(path, &block)
-        http(:get, path, &block)
-      end
+        def http(method, path, &block)
+          _conn.send(method, path, &block)
+        end
 
-      def delete(path, &block)
-        http(:delete, path, &block)
-      end
+        def send_event(event, topic, callback, timestamp = nil)
+          data = { type: event, url: callback, timestamp: timestamp }
 
-      def send_event(event, topic, callback, timestamp = nil)
-        data = { type: event, url: callback, timestamp: timestamp }
+          response = post("/topics/#{topic}") do |r|
+            r.headers['Content-Type'] = 'application/json'
+            r.body = Oj.dump(_stringify_keys data)
+          end
+          fail "event rejected (#{response.status})" unless response.success?
 
-        response = post("/topics/#{topic}") do |r|
-          r.headers['Content-Type'] = 'application/json'
-          r.body = Oj.dump(_stringify_keys data)
+          # Any issues would have caused an exception to be thrown
+          true
         end
-        fail "event rejected (#{response.status})" unless response.success?
-      end
 
-      def subscribe(options)
-        response = post('/subscription') do |r|
-          r.headers['Content-Type'] = 'application/json'
-          r.body = Oj.dump(_stringify_keys options)
-        end
+        def subscribe(options)
+          response = post('/subscription') do |r|
+            r.headers['Content-Type'] = 'application/json'
+            r.body = Oj.dump(_stringify_keys options)
+          end
 
-        unless response.success?
-          raise 'subscribe rejected'
+          unless response.success?
+            raise 'subscribe rejected'
+          end
         end
-      end
 
-      private
+        private
+
+        def_delegators :'Routemaster::Client::Configuration', :url, :timeout, :uuid, :verify_ssl
 
-      def _stringify_keys(hash)
-        hash.dup.tap do |h|
-          h.keys.each do |k|
-            h[k.to_s] = h.delete(k)
+        def _stringify_keys(hash)
+          hash.dup.tap do |h|
+            h.keys.each do |k|
+              h[k.to_s] = h.delete(k)
+            end
           end
         end
-      end
 
-      def _conn
-        @_conn ||= Faraday.new(@_url, ssl: { verify: @_verify_ssl }) do |f|
-          f.request :retry, max: 2, interval: 100e-3, backoff_factor: 2
-          f.request :basic_auth, @_uuid, 'x'
-          f.adapter :typhoeus
+        def _conn
+          @_conn ||= Faraday.new(url, ssl: { verify: verify_ssl }) do |f|
+            f.request :retry, max: 2, interval: 100e-3, backoff_factor: 2
+            f.request :basic_auth, uuid, 'x'
+            f.adapter :typhoeus
 
-          f.options.timeout      = @_timeout
-          f.options.open_timeout = @_timeout
+            f.options.timeout      = timeout
+            f.options.open_timeout = timeout
+          end
         end
       end
     end

data/routemaster/client/errors.rb

@@ -0,0 +1,12 @@
+module Routemaster
+  module Client
+    class Error < StandardError; end
+    class ArgumentError < ArgumentError; end
+
+    class InvalidArgumentError       < ArgumentError; end
+    class ConfigurationError         < Error; end
+    class MissingAsyncBackendError   < Error; end
+    class MissingAttributeError      < ConfigurationError; end
+    class InvalidAttributeError      < ConfigurationError; end
+  end
+end

data/routemaster/client/version.rb

@@ -1,5 +1,5 @@
 module Routemaster
-  class Client
-    VERSION = '2.1.0'
+  module Client
+    VERSION = '3.0.0'
   end
 end

data/spec/client/backends/sidekiq/configuration_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'spec/support/configuration_helper'
+require 'routemaster/client/backends/sidekiq/configuration'
+
+describe Routemaster::Client::Backends::Sidekiq::Configuration do
+  reset_sidekiq_config_between_tests!
+
+  describe '#configure' do
+
+    it 'sets sidekiq_options to empty hash if nothing is specified' do
+      Routemaster::Client::Backends::Sidekiq::Configuration.configure {}
+      expect(sidekiq_options).to eq({})
+    end
+
+    describe 'queue' do
+      it 'sets the queue with a string key, and stringifies the value' do
+        Routemaster::Client::Backends::Sidekiq::Configuration.configure do |c|
+          c.queue = :nice_queue
+        end
+        expect(sidekiq_options['queue']).to eq 'nice_queue'
+      end
+    end
+
+    describe 'backtrace' do
+      it 'sets the backtrace with a string key' do
+        Routemaster::Client::Backends::Sidekiq::Configuration.configure do |c|
+          c.backtrace = true
+        end
+        expect(sidekiq_options['backtrace']).to eq true
+      end
+    end
+
+    describe 'retry' do
+      it 'sets the retry with a string key' do
+        Routemaster::Client::Backends::Sidekiq::Configuration.configure do |c|
+          c.retry = true
+        end
+        expect(sidekiq_options['retry']).to eq true
+      end
+    end
+
+    describe 'pool' do
+      it 'sets the pool with a string key' do
+        pool = double
+        Routemaster::Client::Backends::Sidekiq::Configuration.configure do |c|
+          c.pool = pool
+        end
+        expect(sidekiq_options['pool']).to eq pool
+      end
+    end
+
+    describe 'sidekiq_options'  do
+      it 'cannot be modified after configuration' do
+        Routemaster::Client::Backends::Sidekiq::Configuration.configure {}
+        Routemaster::Client::Backends::Sidekiq::Configuration.sidekiq_options[:key_that_dont_exist] = 'Weeee'
+        expect(Routemaster::Client::Backends::Sidekiq::Configuration.sidekiq_options).to_not have_key(:key_that_dont_exist)
+      end
+    end
+  end
+end
+
+def sidekiq_options
+  Routemaster::Client::Backends::Sidekiq::Configuration.sidekiq_options
+end

data/spec/client/configuration_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+require 'spec/support/configuration_helper'
+require 'routemaster/client/configuration'
+
+describe Routemaster::Client::Configuration do
+
+  reset_config_between_tests!
+
+  describe '#configure' do
+    describe 'url' do
+      it 'raises an error if url is not defined' do
+        configure = -> do
+          Routemaster::Client::Configuration.configure do |config|
+            config.uuid = 'I_am_a_magical_uuid'
+          end
+        end
+
+        expected_message = 'url is required'
+        expect(&configure).to raise_error Routemaster::Client::MissingAttributeError, expected_message
+      end
+
+      it 'raises an error if url is invalid' do
+        configure = -> do
+          Routemaster::Client::Configuration.configure do |config|
+            config.uuid = 'I_am_a_magical_uuid'
+            config.url = 'not a proper url at all'
+          end
+        end
+
+        expected_message = "url 'not a proper url at all' is invalid, must be an https url"
+        expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+      end
+
+      it 'raises an error if url is not https' do
+        configure = -> do
+          Routemaster::Client::Configuration.configure do |config|
+            config.uuid = 'I_am_a_magical_uuid'
+            config.url = 'http://example.com'
+          end
+        end
+
+        expected_message = "url 'http://example.com' is invalid, must be an https url"
+        expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+      end
+    end
+
+    describe 'uuid' do
+      it 'raises an error if uuid if not defined' do
+        configure = -> do
+          Routemaster::Client::Configuration.configure do |config|
+            config.url = 'https://example.com'
+          end
+        end
+
+        expect(&configure).to raise_error Routemaster::Client::MissingAttributeError
+      end
+
+      it 'requires an error if uuid is not alphanumeric (plus dashes and underscores)' do
+        configure = -> do
+          Routemaster::Client::Configuration.configure do |config|
+            config.url = 'https://example.com'
+            config.uuid = '$$$INVALID'
+          end
+        end
+
+        expected_message =  "uuid '$$$INVALID' is invalid, must only contain alphanumeric characters " +
+          'plus _ and - and be 1 to 64 characters'
+        expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+      end
+    end
+
+    it "does not raise an error if both uuid and url are defined and are valid" do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://lovely.com'
+          config.uuid = 'uiiiiiiidddd'
+        end
+      end
+
+      expect(&configure).to_not raise_error
+    end
+  end
+
+  describe 'timeout' do
+    it 'raises an error if timeout is not an integer' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = "uiiiiiiidddd"
+          config.timeout = 'one'
+        end
+      end
+
+      expected_message =  "timeout 'one' is invalid, must be an integer between 0 and 3,600,000"
+      expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+    end
+
+    it 'raises an error if timeout is too large' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.timeout = 1_000_000_000_000_000_000_000_000_000_000_000_000
+        end
+      end
+
+      expected_message =  "timeout '1000000000000000000000000000000000000' is invalid, must be an integer between 0 and 3,600,000"
+      expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+    end
+
+    it 'does not raise an error if the timeout is valid' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://lovely.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.timeout = 2
+        end
+      end
+
+      expect(&configure).to_not raise_error
+    end
+
+    it 'will default to 5 if not supplied' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://lovely.com'
+          config.uuid = 'uiiiiiiidddd'
+        end
+      end
+
+      expect(&configure).to_not raise_error
+      expect(Routemaster::Client::Configuration.timeout).to eq 5
+    end
+  end
+
+  describe 'lazy' do
+    it 'raises an error if lazy is not a boolean' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.lazy = 'yes'
+        end
+      end
+
+      expected_message =  "lazy 'yes' is invalid, must be a boolean value: true or false"
+      expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+    end
+
+    it 'does not raise an error if lazy is a boolean' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.lazy = true
+        end
+      end
+
+      expect(&configure).to_not raise_error
+      expect(Routemaster::Client::Configuration.lazy).to eq true
+    end
+
+    it 'will default to false if not supplied' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://lovely.com'
+          config.uuid = 'uiiiiiiidddd'
+        end
+      end
+
+      expect(&configure).to_not raise_error
+      expect(Routemaster::Client::Configuration.lazy).to eq false
+    end
+  end
+
+  describe 'verify_ssl' do
+    it 'raises an error if verify_ssl is not a boolean' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.verify_ssl = 'yes'
+        end
+      end
+
+      expected_message =  "verify_ssl 'yes' is invalid, must be a boolean value: true or false"
+      expect(&configure).to raise_error Routemaster::Client::InvalidAttributeError, expected_message
+    end
+
+    it 'does not raise an error if verify_ssl is a boolean' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://example.com'
+          config.uuid = 'uiiiiiiidddd'
+          config.verify_ssl = false
+        end
+      end
+
+      expect(&configure).to_not raise_error
+      expect(Routemaster::Client::Configuration.verify_ssl).to eq false
+    end
+
+    it 'will default to true if not supplied' do
+      configure = -> do
+        Routemaster::Client::Configuration.configure do |config|
+          config.url = 'https://lovely.com'
+          config.uuid = 'uiiiiiiidddd'
+        end
+      end
+
+      expect(&configure).to_not raise_error
+      expect(Routemaster::Client::Configuration.verify_ssl).to eq true
+    end
+  end
+end