makara 0.3.5

data/spec/cache_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Makara::Cache do
+
+  it 'should not require a store be set' do
+    described_class.store = nil
+
+    expect(
+      described_class.send(:store)
+    ).to be_nil
+
+    expect{
+      described_class.read('test')
+    }.not_to raise_error
+  end
+
+  it 'provides a few stores for testing purposes' do
+    described_class.store = :memory
+    described_class.write('test', 'value', 10)
+    expect(described_class.read('test')).to eq('value')
+
+    described_class.store = :noop
+    described_class.write('test', 'value', 10)
+    expect(described_class.read('test')).to be_nil
+  end
+
+
+  # this will be used in tests so we have to ensure this works as expected
+  context Makara::Cache::MemoryStore do
+
+    let(:store){ Makara::Cache::MemoryStore.new }
+    let(:data){ store.instance_variable_get('@data') }
+
+    it 'should read and write keys' do
+      expect(store.read('test')).to be_nil
+      store.write('test', 'value')
+      expect(store.read('test')).to eq('value')
+    end
+
+    it 'provides time based expiration' do
+      store.write('test', 'value', :expires_in => 5)
+      expect(store.read('test')).to eq('value')
+
+      Timecop.travel Time.now + 6 do
+        expect(store.read('test')).to be_nil
+      end
+    end
+
+    it 'cleans the data' do
+      store.write('test', 'value', :expires_in => -5)
+      expect(store.read('test')).to be_nil
+      expect(data).not_to have_key('test')
+    end
+
+  end
+
+
+
+end

data/spec/config_parser_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Makara::ConfigParser do
+
+  let(:config){
+    {
+      :top_level => 'value',
+      :makara => {
+        :connections => [
+          {
+            :role => 'master',
+            :name => 'themaster'
+          },
+          {
+            :name => 'slave1'
+          },
+          {
+            :name => 'slave2'
+          }
+        ]
+      }
+    }
+  }
+
+  context '::merge_and_resolve_default_url_config' do
+    let(:config_without_url) do
+      {
+        :master_ttl => 5,
+        :blacklist_duration => 30,
+        :sticky => true,
+        :adapter => 'mysql2_makara',
+        :encoding => 'utf8',
+        :host => 'localhost',
+        :database => 'db_name',
+        :username => 'db_username',
+        :password => 'db_password',
+        :port =>     3306
+      }
+    end
+
+    let(:config_with_url) do
+      {
+        :master_ttl => 5,
+        :blacklist_duration => 30,
+        :sticky => true,
+        :adapter => 'mysql2_makara',
+        :encoding => 'utf8',
+        :url => 'mysql2://db_username:db_password@localhost:3306/db_name'
+      }
+    end
+
+    it 'does nothing to a config without a url parameter' do
+      config = config_without_url.dup
+      expected = config_without_url.dup
+      actual = described_class.merge_and_resolve_default_url_config(config)
+      expect(actual).to eq(expected)
+    end
+
+    it 'parses the url parameter and merges it into the config' do
+      config = config_with_url.dup
+      expected = config_without_url.dup
+      actual = described_class.merge_and_resolve_default_url_config(config)
+      expect(actual).to eq(expected)
+    end
+
+    it 'does not use DATABASE_URL env variable' do
+      database_url = ENV['DATABASE_URL']
+      ENV['DATABASE_URL'] = config_with_url[:url]
+      begin
+        config = config_with_url.dup
+        config.delete(:url)
+        expected = config.dup
+        actual = described_class.merge_and_resolve_default_url_config(config)
+        expect(actual).to eq(expected)
+      ensure
+        ENV['DATABASE_URL'] = database_url
+      end
+    end
+
+  end
+
+  it 'should provide an id based on the recursively sorted config' do
+    parsera = described_class.new(config)
+    parserb = described_class.new(config.merge(:other => 'value'))
+    parserc = described_class.new(config)
+
+    expect(parsera.id).not_to eq(parserb.id)
+    expect(parsera.id).to eq(parserc.id)
+  end
+
+  it 'should provide master and slave configs' do
+    parser = described_class.new(config)
+    expect(parser.master_configs).to eq([
+      {:name => 'themaster', :top_level => 'value', :blacklist_duration => 30, :master_ttl => 5, :sticky => true}
+    ])
+    expect(parser.slave_configs).to eq([
+      {:name => 'slave1', :top_level => 'value', :blacklist_duration => 30, :master_ttl => 5, :sticky => true},
+      {:name => 'slave2', :top_level => 'value', :blacklist_duration => 30, :master_ttl => 5, :sticky => true}
+    ])
+  end
+
+end

data/spec/connection_wrapper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Makara::ConnectionWrapper do
+
+  let(:proxy){ FakeProxy.new({:makara => {:blacklist_duration => 5, :connections => [{:role => 'master'}, {:role => 'slave'}, {:role => 'slave'}]}}) }
+  let(:connection){ subject._makara_connection }
+
+  subject{ proxy.master_pool.connections.first }
+
+  it 'should extend the connection with new functionality' do
+    expect(connection).to respond_to(:_makara_name)
+    expect(connection).to respond_to(:_makara)
+    expect(connection).to respond_to(:_makara_hijack)
+  end
+
+  it 'should invoke hijacked methods on the proxy when invoked directly' do
+    expect(proxy).to receive(:execute).with('test').once
+    connection.execute("test")
+  end
+
+  it 'should have a default weight of 1' do
+    expect(subject._makara_weight).to eq(1)
+  end
+
+  it 'should store the blacklist status' do
+    expect(subject._makara_blacklisted?).to eq(false)
+    subject._makara_blacklist!
+    expect(subject._makara_blacklisted?).to eq(true)
+    subject._makara_whitelist!
+    expect(subject._makara_blacklisted?).to eq(false)
+  end
+
+end

data/spec/context_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Makara::Context do
+
+  describe 'get_current' do
+    it 'does not share context acorss threads' do
+      uniq_curret_contexts = []
+      threads = []
+
+      1.upto(3).map do |i|
+        threads << Thread.new do
+          current = Makara::Context.get_current
+          expect(current).to_not be_nil
+          expect(uniq_curret_contexts).to_not include(current)
+          uniq_curret_contexts << current
+
+          sleep(0.2)
+        end
+        sleep(0.1)
+      end
+
+      threads.map(&:join)
+      expect(uniq_curret_contexts.uniq.count).to eq(3)
+    end
+  end
+
+  describe 'set_current' do
+
+    it 'does not share context acorss threads' do
+      uniq_curret_contexts = []
+      threads = []
+
+      1.upto(3).map do |i|
+        threads << Thread.new do
+
+          current = Makara::Context.set_current("val#{i}")
+          expect(current).to_not be_nil
+          expect(current).to eq("val#{i}")
+
+          sleep(0.2)
+
+          current = Makara::Context.get_current
+          expect(current).to_not be_nil
+          expect(current).to eq("val#{i}")
+
+          uniq_curret_contexts << current
+        end
+        sleep(0.1)
+      end
+
+      threads.map(&:join)
+      expect(uniq_curret_contexts.uniq.count).to eq(3)
+    end
+  end
+
+  describe 'get_previous' do
+    it 'does not share context acorss threads' do
+      uniq_curret_contexts = []
+      threads = []
+
+      1.upto(3).map do |i|
+        threads << Thread.new do
+          current = Makara::Context.get_previous
+          expect(current).to_not be_nil
+          expect(uniq_curret_contexts).to_not include(current)
+          uniq_curret_contexts << current
+
+          sleep(0.2)
+        end
+        sleep(0.1)
+      end
+
+      threads.map(&:join)
+      expect(uniq_curret_contexts.uniq.count).to eq(3)
+    end
+  end
+
+  describe 'set_previous' do
+    it 'does not share context acorss threads' do
+      uniq_curret_contexts = []
+      threads = []
+
+      1.upto(3).map do |i|
+        threads << Thread.new do
+
+          current = Makara::Context.set_previous("val#{i}")
+          expect(current).to_not be_nil
+          expect(current).to eq("val#{i}")
+
+          sleep(0.2)
+
+          current = Makara::Context.get_previous
+          expect(current).to_not be_nil
+          expect(current).to eq("val#{i}")
+
+          uniq_curret_contexts << current
+        end
+        sleep(0.1)
+      end
+
+      threads.map(&:join)
+      expect(uniq_curret_contexts.uniq.count).to eq(3)
+    end
+  end
+
+end
+

data/spec/middleware_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Makara::Middleware do
+
+  let(:app){
+    lambda{|env|
+      proxy.query(env[:query] || 'select * from users')
+      [200, {}, ["#{Makara::Context.get_current}-#{Makara::Context.get_previous}"]]
+    }
+  }
+
+  let(:env){ {} }
+  let(:proxy){ FakeProxy.new(config(1,2)) }
+  let(:middleware){ described_class.new(app) }
+
+  let(:key){ Makara::Middleware::IDENTIFIER }
+
+  it 'should set the context before the request' do
+    Makara::Context.set_previous 'old'
+    Makara::Context.set_current 'old'
+
+    response = middleware.call(env)
+    current, prev = context_from(response)
+
+    expect(current).not_to eq('old')
+    expect(prev).not_to eq('old')
+
+    expect(current).to eq(Makara::Context.get_current)
+    expect(prev).to eq(Makara::Context.get_previous)
+  end
+
+  it 'should use the cookie-provided context if present' do
+    env['HTTP_COOKIE'] = "#{key}=abcdefg--200; path=/; max-age=5"
+
+    response = middleware.call(env)
+    current, prev = context_from(response)
+
+    expect(prev).to eq('abcdefg')
+    expect(current).to eq(Makara::Context.get_current)
+    expect(current).not_to eq('abcdefg')
+  end
+
+  it 'should use the param-provided context if present' do
+    env['QUERY_STRING'] = "dog=true&#{key}=abcdefg&cat=false"
+
+    response = middleware.call(env)
+    current, prev = context_from(response)
+
+    expect(prev).to eq('abcdefg')
+    expect(current).to eq(Makara::Context.get_current)
+    expect(current).not_to eq('abcdefg')
+  end
+
+  it 'should set the cookie if master is used' do
+    env[:query] = 'update users set name = "phil"'
+
+    status, headers, body = middleware.call(env)
+
+    expect(headers['Set-Cookie']).to eq("#{key}=#{Makara::Context.get_current}--200; path=/; max-age=5; HttpOnly")
+  end
+
+  it 'should preserve the same context if the previous request was a redirect' do
+    env['HTTP_COOKIE'] = "#{key}=abcdefg--301; path=/; max-age=5"
+
+    response    = middleware.call(env)
+    curr, prev  = context_from(response)
+
+    expect(curr).to eq('abcdefg')
+    expect(prev).to eq('abcdefg')
+
+    env['HTTP_COOKIE'] = response[1]['Set-Cookie']
+
+    response      = middleware.call(env)
+    curr2, prev2  = context_from(response)
+
+    expect(prev2).to eq('abcdefg')
+    expect(curr2).to eq(Makara::Context.get_current)
+  end
+
+  def context_from(response)
+    response[2][0].split('-')
+  end
+
+end

data/spec/pool_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Makara::Pool do
+
+  let(:proxy){ FakeProxy.new({:makara => pool_config.merge(:connections => [])}) }
+  let(:pool){ Makara::Pool.new('test', proxy) }
+  let(:pool_config){ {:blacklist_duration => 5} }
+
+  it 'should wrap connections with a ConnectionWrapper as theyre added to the pool' do
+    expect(pool.connections).to be_empty
+
+    connection_a = FakeConnection.new
+    connection_a.something = 'a'
+
+    wrapper_a = pool.add(pool_config){ connection_a }
+    wrapper_b = pool.add(pool_config.merge(:weight => 2)){ FakeConnection.new }
+
+    expect(pool.connections.length).to eq(3)
+
+    expect(wrapper_a).to be_a(Makara::ConnectionWrapper)
+    expect(wrapper_a.irespondtothis).to eq('hey!')
+
+    as, bs = pool.connections.partition{|c| c.something == 'a'}
+    expect(as.length).to eq(1)
+    expect(bs.length).to eq(2)
+  end
+
+  it 'should determine if its completely blacklisted' do
+
+    pool.add(pool_config){ FakeConnection.new }
+    pool.add(pool_config){ FakeConnection.new }
+
+    expect(pool).not_to be_completely_blacklisted
+
+    pool.connections.each(&:_makara_blacklist!)
+
+    expect(pool).to be_completely_blacklisted
+  end
+
+  it 'sends methods to all underlying objects if asked to' do
+
+    a = FakeConnection.new
+    b = FakeConnection.new
+
+    pool.add(pool_config){ a }
+    pool.add(pool_config){ b }
+
+    expect(a).to receive(:query).with('test').once
+    expect(b).to receive(:query).with('test').once
+
+    pool.send_to_all :query, 'test'
+
+  end
+
+  it 'only sends methods to underlying objects which are not blacklisted' do
+
+    a = FakeConnection.new
+    b = FakeConnection.new
+    c = FakeConnection.new
+
+    pool.add(pool_config){ a }
+    pool.add(pool_config){ b }
+    wrapper_c = pool.add(pool_config){ c }
+
+    expect(a).to receive(:query).with('test').once
+    expect(b).to receive(:query).with('test').once
+    expect(c).to receive(:query).with('test').never
+
+    wrapper_c._makara_blacklist!
+
+    pool.send_to_all :query, 'test'
+
+  end
+
+  it 'provides the next connection and blacklists' do
+
+    connection_a = FakeConnection.new
+    connection_b = FakeConnection.new
+
+    wrapper_a = pool.add(pool_config){ connection_a }
+    wrapper_b = pool.add(pool_config){ connection_b }
+
+    pool.provide do |connection|
+      if connection == wrapper_a
+        raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+      end
+    end
+
+    expect(wrapper_a._makara_blacklisted?).to eq(true)
+    expect(wrapper_b._makara_blacklisted?).to eq(false)
+
+    Timecop.travel Time.now + 10 do
+      expect(wrapper_a._makara_blacklisted?).to eq(false)
+      expect(wrapper_b._makara_blacklisted?).to eq(false)
+    end
+
+  end
+
+  it 'provides the same connection if the context has not changed and the proxy is sticky' do
+    allow(proxy).to receive(:sticky){ true }
+
+    pool.add(pool_config){ FakeConnection.new }
+    pool.add(pool_config){ FakeConnection.new }
+
+    provided = []
+
+    10.times{ pool.provide{|con| provided << con } }
+
+    expect(provided.uniq.length).to eq(1)
+  end
+
+  it 'does not provide the same connection if the proxy is not sticky' do
+    allow(proxy).to receive(:sticky){ false }
+
+    pool.add(pool_config){ FakeConnection.new }
+    pool.add(pool_config){ FakeConnection.new }
+
+    provided = []
+
+    10.times{ pool.provide{|con| provided << con } }
+
+    expect(provided.uniq.length).to eq(2)
+  end
+
+  it 'raises an error when all connections are blacklisted' do
+
+    wrapper_a = pool.add(pool_config.dup){ FakeConnection.new }
+    wrapper_b = pool.add(pool_config.dup){ FakeConnection.new }
+
+    # make the connection
+    pool.send_to_all :to_s
+
+    allow(pool).to receive(:next).and_return(wrapper_a, wrapper_b, nil)
+
+
+    begin
+      pool.provide do |connection|
+        raise Makara::Errors::BlacklistConnection.new(connection, StandardError.new('failure'))
+      end
+    rescue Makara::Errors::AllConnectionsBlacklisted => e
+      expect(e).to be_present
+      expect(e.message).to eq("[Makara/test] All connections are blacklisted -> [Makara/test/2] failure -> [Makara/test/1] failure")
+    end
+  end
+
+  it 'skips blacklisted connections when choosing the next one' do
+
+    pool.add(pool_config){ FakeConnection.new }
+    pool.add(pool_config){ FakeConnection.new }
+
+    wrapper_b = pool.add(pool_config){ FakeConnection.new }
+    wrapper_b._makara_blacklist!
+
+    10.times{ pool.provide{|connection| expect(connection).not_to eq(wrapper_b) } }
+
+  end
+
+end