lhm-shopify 3.3.5

data/spec/unit/throttler/slave_lag_spec.rb

@@ -0,0 +1,317 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../unit_helper'
+
+require 'lhm/throttler/slave_lag'
+
+describe Lhm::Throttler do
+  include UnitHelper
+
+  describe '#format_hosts' do
+    describe 'with only localhost hosts' do
+      it 'returns no hosts' do
+        assert_equal([], Lhm::Throttler.format_hosts(['localhost:1234', '127.0.0.1:5678']))
+      end
+    end
+
+    describe 'with only remote hosts' do
+      it 'returns remote hosts' do
+        assert_equal(['server.example.com', 'anotherserver.example.com'], Lhm::Throttler.format_hosts(['server.example.com:1234', 'anotherserver.example.com']))
+      end
+    end
+
+    describe 'with only nil hosts' do
+      it 'returns no hosts' do
+        assert_equal([], Lhm::Throttler.format_hosts([nil]))
+      end
+    end
+
+    describe 'with some nil hosts' do
+      it 'returns the remaining hosts' do
+        assert_equal(['server.example.com'], Lhm::Throttler.format_hosts([nil, 'server.example.com:1234']))
+      end
+    end
+  end
+end
+
+describe Lhm::Throttler::Slave do
+  include UnitHelper
+
+  before :each do
+    @logs = StringIO.new
+    Lhm.logger = Logger.new(@logs)
+
+    @dummy_mysql_client_config = lambda { {'username' => 'user', 'password' => 'pw', 'database' => 'db'} }
+  end
+
+  describe "#client" do
+    before do
+      class TestMysql2Client
+        def initialize(config)
+          raise Mysql2::Error.new("connection error")
+        end
+      end
+    end
+
+    describe 'on connection error' do
+      it 'logs and returns nil' do
+        assert_nil(Lhm::Throttler::Slave.new('slave', @dummy_mysql_client_config).connection)
+
+        log_messages = @logs.string.lines
+        assert_equal(2, log_messages.length)
+        assert log_messages[0].include? "Connecting to slave on database: db"
+        assert log_messages[1].include? "Error connecting to slave: Unknown MySQL server host 'slave'"
+      end
+    end
+
+    describe 'with proper config' do
+      it "creates a new Mysql2::Client" do
+        expected_config = {username: 'user', password: 'pw', database: 'db', host: 'slave'}
+        Mysql2::Client.stubs(:new).with(expected_config).returns(mock())
+
+        assert Lhm::Throttler::Slave.new('slave', @dummy_mysql_client_config).connection
+      end
+    end
+
+    describe 'with active record config' do
+      it 'logs and creates client' do
+        active_record_config = {username: 'user', password: 'pw', database: 'db'}
+        ActiveRecord::Base.stubs(:connection_pool).returns(stub(spec: stub(config: active_record_config)))
+
+        Mysql2::Client.stubs(:new).returns(mock())
+
+        assert Lhm::Throttler::Slave.new('slave').connection
+
+        log_messages = @logs.string.lines
+        assert_equal(1, log_messages.length)
+        assert log_messages[0].include? "Connecting to slave on database: db"
+      end
+    end
+  end
+
+  describe "#connection" do
+    before do
+      class Connection
+        def self.query(query)
+          if query == Lhm::Throttler::Slave::SQL_SELECT_MAX_SLAVE_LAG
+            [{'Seconds_Behind_Master' => 20}]
+          elsif query == Lhm::Throttler::Slave::SQL_SELECT_SLAVE_HOSTS
+            [{'host' => '1.1.1.1:80'}]
+          end
+        end
+      end
+
+      @slave = Lhm::Throttler::Slave.new('slave', @dummy_mysql_client_config)
+      @slave.instance_variable_set(:@connection, Connection)
+
+      class StoppedConnection
+        def self.query(query)
+          [{'Seconds_Behind_Master' => nil}]
+        end
+      end
+
+      @stopped_slave = Lhm::Throttler::Slave.new('stopped_slave', @dummy_mysql_client_config)
+      @stopped_slave.instance_variable_set(:@connection, StoppedConnection)
+    end
+
+    describe "#lag" do
+      it "returns the slave lag" do
+        assert_equal(20, @slave.lag)
+      end
+    end
+
+    describe "#lag with a stopped slave" do
+      it "returns 0 slave lag" do
+        assert_equal(0, @stopped_slave.lag)
+      end
+    end
+
+    describe "#slave_hosts" do
+      it "returns the hosts" do
+        assert_equal(['1.1.1.1'], @slave.slave_hosts)
+      end
+    end
+
+    describe "#lag on connection error" do
+      it "logs and returns 0 slave lag" do
+        client = mock()
+        client.stubs(:query).raises(Mysql2::Error, "Can't connect to MySQL server")
+        Lhm::Throttler::Slave.any_instance.stubs(:client).returns(client)
+        Lhm::Throttler::Slave.any_instance.stubs(:config).returns([])
+
+        slave = Lhm::Throttler::Slave.new('slave', @dummy_mysql_client_config)
+        assert_send([Lhm.logger, :info, "Unable to connect and/or query slave: error"])
+        assert_equal(0, slave.lag)
+      end
+    end
+  end
+end
+
+describe Lhm::Throttler::SlaveLag do
+  include UnitHelper
+
+  before :each do
+    @throttler = Lhm::Throttler::SlaveLag.new
+  end
+
+  describe '#throttle_seconds' do
+    describe 'with no slave lag' do
+      before do
+        def @throttler.max_current_slave_lag
+          0
+        end
+      end
+
+      it 'does not alter the currently set timeout' do
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout, @throttler.send(:throttle_seconds))
+      end
+    end
+
+    describe 'with a large slave lag' do
+      before do
+        def @throttler.max_current_slave_lag
+          100
+        end
+      end
+
+      it 'doubles the currently set timeout' do
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout * 2, @throttler.send(:throttle_seconds))
+      end
+
+      it 'does not increase the timeout past the maximum' do
+        @throttler.timeout_seconds = Lhm::Throttler::SlaveLag::MAX_TIMEOUT
+        assert_equal(Lhm::Throttler::SlaveLag::MAX_TIMEOUT, @throttler.send(:throttle_seconds))
+      end
+    end
+
+    describe 'with no slave lag after it has previously been increased' do
+      before do
+        def @throttler.max_current_slave_lag
+          0
+        end
+      end
+
+      it 'halves the currently set timeout' do
+        @throttler.timeout_seconds *= 2 * 2
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout / 2, @throttler.send(:throttle_seconds))
+      end
+
+      it 'does not decrease the timeout past the minimum on repeated runs' do
+        @throttler.timeout_seconds = Lhm::Throttler::SlaveLag::INITIAL_TIMEOUT * 2
+        assert_equal(Lhm::Throttler::SlaveLag::INITIAL_TIMEOUT, @throttler.send(:throttle_seconds))
+        assert_equal(Lhm::Throttler::SlaveLag::INITIAL_TIMEOUT, @throttler.send(:throttle_seconds))
+      end
+    end
+  end
+
+  describe '#max_current_slave_lag' do
+    describe 'with multiple slaves' do
+      it 'returns the largest amount of lag' do
+        slave1 = mock()
+        slave2 = mock()
+        slave1.stubs(:lag).returns(5)
+        slave2.stubs(:lag).returns(0)
+        Lhm::Throttler::SlaveLag.any_instance.stubs(:slaves).returns([slave1, slave2])
+        assert_equal 5, @throttler.send(:max_current_slave_lag)
+      end
+    end
+
+    describe 'with MySQL stopped on the slave' do
+      it 'assumes 0 slave lag' do
+        client = mock()
+        client.stubs(:query).raises(Mysql2::Error, "Can't connect to MySQL server")
+        Lhm::Throttler::Slave.any_instance.stubs(:client).returns(client)
+
+        Lhm::Throttler::Slave.any_instance.stubs(:prepare_connection_config).returns([])
+        Lhm::Throttler::Slave.any_instance.stubs(:slave_hosts).returns(['1.1.1.2'])
+        @throttler.stubs(:master_slave_hosts).returns(['1.1.1.1'])
+
+        assert_equal 0, @throttler.send(:max_current_slave_lag)
+      end
+    end
+  end
+
+  describe '#get_slaves' do
+    describe 'with no slaves' do
+      before do
+        def @throttler.master_slave_hosts
+          []
+        end
+      end
+
+      it 'returns no slaves' do
+        assert_equal([], @throttler.send(:get_slaves))
+      end
+    end
+
+    describe 'with multiple slaves' do
+      before do
+        class TestSlave
+          attr_reader :host, :connection
+
+          def initialize(host, _)
+            @host = host
+            @connection = 'conn' if @host
+          end
+
+          def slave_hosts
+            if @host == '1.1.1.1'
+              ['1.1.1.2', '1.1.1.3']
+            else
+              [nil]
+            end
+          end
+        end
+
+        @create_slave = lambda { |host, config|
+          TestSlave.new(host, config)
+        }
+      end
+
+      describe 'without the :check_only option' do
+        before do
+          def @throttler.master_slave_hosts
+            ['1.1.1.1', '1.1.1.4']
+          end
+        end
+
+        it 'returns the slave instances' do
+          Lhm::Throttler::Slave.stubs(:new).returns(@create_slave) do
+            assert_equal(["1.1.1.4", "1.1.1.1", "1.1.1.3", "1.1.1.2"], @throttler.send(:get_slaves).map(&:host))
+          end
+        end
+      end
+
+      describe 'with the :check_only option' do
+        describe 'with a callable argument' do
+          before do
+            check_only = lambda {{'host' => '1.1.1.3'}}
+            @throttler = Lhm::Throttler::SlaveLag.new :check_only => check_only
+          end
+
+          it 'returns only that single slave' do
+            Lhm::Throttler::Slave.stubs(:new).returns(@create_slave) do
+              assert_equal ['1.1.1.3'], @throttler.send(:get_slaves).map(&:host)
+            end
+          end
+        end
+
+        describe 'with a non-callable argument' do
+          before do
+            @throttler = Lhm::Throttler::SlaveLag.new :check_only => 'I cannot be called'
+            def @throttler.master_slave_hosts
+              ['1.1.1.1', '1.1.1.4']
+            end
+          end
+
+          it 'returns all the slave instances' do
+            Lhm::Throttler::Slave.stubs(:new).returns(@create_slave) do
+              assert_equal(["1.1.1.4", "1.1.1.1", "1.1.1.3", "1.1.1.2"], @throttler.send(:get_slaves).map(&:host))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/throttler/threads_running_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../unit_helper'
+
+require 'lhm/throttler/threads_running'
+
+describe Lhm::Throttler::ThreadsRunning do
+  include UnitHelper
+
+  before :each do
+    @throttler = Lhm::Throttler::ThreadsRunning.new
+  end
+
+  describe '#throttle_seconds' do
+    describe 'with no mysql activity' do
+      before do
+        def @throttler.threads_running
+          0
+        end
+      end
+
+      it 'does not alter the currently set timeout' do
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout, @throttler.send(:throttle_seconds))
+      end
+    end
+
+    describe 'with an overloaded mysql' do
+      before do
+        def @throttler.threads_running
+          100
+        end
+      end
+
+      it 'doubles the currently set timeout' do
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout * 2, @throttler.send(:throttle_seconds))
+      end
+
+      it 'does not increase the timeout past the maximum' do
+        @throttler.timeout_seconds = @throttler.max_timeout_seconds
+        assert_equal(@throttler.max_timeout_seconds, @throttler.send(:throttle_seconds))
+      end
+    end
+
+    describe 'with an idle mysql after it has previously been busy' do
+      before do
+        def @throttler.threads_running
+          0
+        end
+      end
+
+      it 'halves the currently set timeout' do
+        @throttler.timeout_seconds *= 2 * 2
+        timeout = @throttler.timeout_seconds
+        assert_equal(timeout / 2, @throttler.send(:throttle_seconds))
+      end
+
+      it 'does not decrease the timeout past the minimum on repeated runs' do
+        @throttler.timeout_seconds = @throttler.initial_timeout_seconds * 2
+        assert_equal(@throttler.initial_timeout_seconds, @throttler.send(:throttle_seconds))
+        assert_equal(@throttler.initial_timeout_seconds, @throttler.send(:throttle_seconds))
+      end
+    end
+  end
+end

data/spec/unit/throttler_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path(File.dirname(__FILE__)) + '/unit_helper'
+
+require 'lhm/throttler'
+
+describe Lhm::Throttler do
+  include UnitHelper
+
+  before :each do
+    @mock = Class.new do
+      extend Lhm::Throttler
+    end
+
+    @conn = Class.new do
+      def execute
+      end
+    end
+  end
+
+  describe '#setup_throttler' do
+    describe 'when passing a time_throttler key' do
+      before do
+        @mock.setup_throttler(:time_throttler, delay: 2)
+      end
+
+      it 'instantiates the time throttle' do
+        @mock.throttler.class.must_equal Lhm::Throttler::Time
+      end
+
+      it 'returns 2 seconds as time' do
+        @mock.throttler.timeout_seconds.must_equal 2
+      end
+    end
+
+    describe 'when passing a slave_lag_throttler key' do
+      before do
+        @mock.setup_throttler(:slave_lag_throttler, allowed_lag: 20)
+      end
+
+      it 'instantiates the slave_lag throttle' do
+        @mock.throttler.class.must_equal Lhm::Throttler::SlaveLag
+      end
+
+      it 'returns 20 seconds as allowed_lag' do
+        @mock.throttler.allowed_lag.must_equal 20
+      end
+    end
+
+    describe 'when passing a time_throttler instance' do
+
+      before do
+        @instance = Class.new(Lhm::Throttler::Time) do
+          def timeout_seconds
+            0
+          end
+        end.new
+
+        @mock.setup_throttler(@instance)
+      end
+
+      it 'returns the instace given' do
+        @mock.throttler.must_equal @instance
+      end
+
+      it 'returns 0 seconds as time' do
+        @mock.throttler.timeout_seconds.must_equal 0
+      end
+    end
+
+    describe 'when passing a slave_lag_throttler instance' do
+
+      before do
+        @instance = Lhm::Throttler::SlaveLag.new
+        def @instance.timeout_seconds
+          0
+        end
+
+        @mock.setup_throttler(@instance)
+      end
+
+      it 'returns the instace given' do
+        @mock.throttler.must_equal @instance
+      end
+
+      it 'returns 0 seconds as time' do
+        @mock.throttler.timeout_seconds.must_equal 0
+      end
+    end
+
+    describe 'when passing a time_throttler class' do
+
+      before do
+        @klass = Class.new(Lhm::Throttler::Time)
+        @mock.setup_throttler(@klass)
+      end
+
+      it 'has the same class as given' do
+        @mock.throttler.class.must_equal @klass
+      end
+    end
+
+    describe 'when passing a slave_lag_throttler class' do
+
+      before do
+        @klass = Class.new(Lhm::Throttler::SlaveLag)
+        @mock.setup_throttler(@klass)
+      end
+
+      it 'has the same class as given' do
+        @mock.throttler.class.must_equal @klass
+      end
+    end
+  end
+
+  describe '#throttler' do
+
+    it 'returns the default Time based' do
+      @mock.throttler.class.must_equal Lhm::Throttler::Time
+    end
+
+    it 'should default to 100 milliseconds' do
+      @mock.throttler.timeout_seconds.must_equal 0.1
+    end
+  end
+end