makara 0.3.8 → 0.5.0

data/spec/active_record/connection_adapters/makara_mysql2_adapter_spec.rb

@@ -82,7 +82,7 @@ describe 'MakaraMysql2Adapter' do
         ActiveRecord::Base.connection
 
         load(File.dirname(__FILE__) + '/../../support/schema.rb')
-        Makara::Context.set_current Makara::Context.generate
+        change_context
 
         allow(ActiveRecord::Base).to receive(:mysql2_connection) do |config|
           config[:username] = db_username
@@ -150,7 +150,7 @@ describe 'MakaraMysql2Adapter' do
 
     it 'should send reads to the slave' do
       # ensure the next connection will be the first one
-      connection.slave_pool.strategy.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+      allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
 
       con = connection.slave_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once
@@ -158,6 +158,21 @@ describe 'MakaraMysql2Adapter' do
       connection.execute('SELECT * FROM users')
     end
 
+    it 'should send exists? to slave' do
+      next if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0 # query doesn't work?
+
+      allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
+      Test::User.exists? # flush other (schema) things that need to happen
+      
+      con = connection.slave_pool.connections.first
+      if (ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 0)
+        expect(con).to receive(:execute).with(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/, any_args).once.and_call_original
+      else
+        expect(con).to receive(:exec_query).with(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/, any_args).once.and_call_original
+      end
+      Test::User.exists?
+    end
+
     it 'should send writes to master' do
       con = connection.master_pool.connections.first
       expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')

data/spec/active_record/connection_adapters/makara_postgis_adapter_spec.rb

@@ -0,0 +1,155 @@
+# RGeo doesn't play well with JRuby and to avoid complicated test setup
+# we're only testing ActiveRecord version ~> 4.2
+# also rgeo only works on 2.1+
+
+rmajor, rminor, rpatch = RUBY_VERSION.split(/[^\d]/)[0..2].map(&:to_i)
+require 'active_record'
+
+# TODO: test this in AR 5+ ?
+
+if RUBY_ENGINE == 'ruby' &&
+    ActiveRecord::VERSION::MAJOR == 4 &&
+    ActiveRecord::VERSION::MINOR >= 2 &&
+    (rmajor > 2 || (rmajor == 2 && rminor >= 1))
+
+  require 'spec_helper'
+  require 'rgeo'
+  require 'activerecord-postgis-adapter'
+  require 'active_record/connection_adapters/postgis_adapter'
+
+  describe 'MakaraPostgisAdapter' do
+    let(:db_username){ ENV['TRAVIS'] ? 'postgres' : `whoami`.chomp }
+
+    let(:config) do
+      base = YAML.load_file(File.expand_path('spec/support/postgis_database.yml'))['test']
+      base['username'] = db_username
+      base
+    end
+
+    let(:connection) { ActiveRecord::Base.connection }
+
+    before :each do
+      ActiveRecord::Base.clear_all_connections!
+      change_context
+    end
+
+    it 'should allow a connection to be established' do
+      ActiveRecord::Base.establish_connection(config)
+      expect(ActiveRecord::Base.connection)
+        .to be_instance_of(ActiveRecord::ConnectionAdapters::MakaraPostgisAdapter)
+    end
+
+    context 'with the connection established and schema loaded' do
+      before do
+        ActiveRecord::Base.establish_connection(config)
+        load(File.dirname(__FILE__) + '/../../support/schema.rb')
+        load(File.dirname(__FILE__) + '/../../support/postgis_schema.rb')
+        change_context
+        RGeo::ActiveRecord::SpatialFactoryStore.instance.tap do |config|
+          # By default, use the GEOS implementation for spatial columns.
+          config.default = RGeo::Geos.factory_generator
+
+          # But use a geographic implementation for point columns.
+          config.register(RGeo::Geographic.spherical_factory(srid: 4326), geo_type: "point")
+        end
+      end
+
+      let(:town_class) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = :towns
+        end
+      end
+
+      it 'should have one master and two slaves' do
+        expect(connection.master_pool.connection_count).to eq(1)
+        expect(connection.slave_pool.connection_count).to eq(2)
+      end
+
+      it 'should allow real queries to work' do
+        connection.execute('INSERT INTO users (name) VALUES (\'John\')')
+
+        connection.master_pool.connections.each do |master|
+          expect(master).to receive(:execute).never
+        end
+
+        change_context
+        res = connection.execute('SELECT name FROM users ORDER BY id DESC LIMIT 1')
+
+        expect(res.to_a[0]['name']).to eq('John')
+      end
+
+      it 'should send SET operations to each connection' do
+        connection.master_pool.connections.each do |con|
+          expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
+        end
+
+        connection.slave_pool.connections.each do |con|
+          expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
+        end
+        connection.execute("SET TimeZone = 'UTC'")
+      end
+
+      it 'should send reads to the slave' do
+        # ensure the next connection will be the first one
+        allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
+
+        con = connection.slave_pool.connections.first
+        expect(con).to receive(:execute).with('SELECT * FROM users').once
+
+        connection.execute('SELECT * FROM users')
+      end
+
+      it 'should send writes to master' do
+        con = connection.master_pool.connections.first
+        expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')
+        connection.execute('UPDATE users SET name = "bob" WHERE id = 1')
+      end
+
+      it 'should interpret points correctly' do
+        town_class.create!(location: 'Point(1 2)')
+        town = town_class.last
+        expect(town.location.x).to eq 1
+        expect(town.location.y).to eq 2
+      end
+    end
+
+    context 'without live connections' do
+      it 'should raise errors on read or write' do
+        allow(ActiveRecord::Base).to receive(:postgis_connection).and_raise(StandardError.new('could not connect to server: Connection refused'))
+
+        ActiveRecord::Base.establish_connection(config)
+        expect { connection.execute('SELECT * FROM users') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+        expect { connection.execute('INSERT INTO users (name) VALUES (\'John\')') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+      end
+    end
+
+    context 'with only master connection' do
+      it 'should not raise errors on read and write' do
+        custom_config = config.deep_dup
+        custom_config['makara']['connections'].select{|h| h['role'] == 'slave' }.each{|h| h['port'] = '1'}
+
+        ActiveRecord::Base.establish_connection(custom_config)
+        load(File.dirname(__FILE__) + '/../../support/schema.rb')
+
+        connection.execute('SELECT * FROM users')
+        connection.execute('INSERT INTO users (name) VALUES (\'John\')')
+      end
+    end
+
+    context 'with only slave connection' do
+      it 'should raise error only on write' do
+        ActiveRecord::Base.establish_connection(config)
+        load(File.dirname(__FILE__) + '/../../support/schema.rb')
+        ActiveRecord::Base.clear_all_connections!
+
+        custom_config = config.deep_dup
+        custom_config['makara']['connections'].select{|h| h['role'] == 'master' }.each{|h| h['port'] = '1'}
+
+        ActiveRecord::Base.establish_connection(custom_config)
+
+        connection.execute('SELECT * FROM users')
+        expect { connection.execute('INSERT INTO users (name) VALUES (\'John\')') }.to raise_error(Makara::Errors::NoConnectionsAvailable)
+      end
+    end
+  end
+end

data/spec/active_record/connection_adapters/makara_postgresql_adapter_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
 require 'active_record/connection_adapters/postgresql_adapter'
+require 'active_record/errors'
 
 describe 'MakaraPostgreSQLAdapter' do
 
   let(:db_username){ ENV['TRAVIS'] ? 'postgres' : `whoami`.chomp }
 
-  let(:config){
+  let(:config) do
     base = YAML.load_file(File.expand_path('spec/support/postgresql_database.yml'))['test']
     base['username'] = db_username
     base
-  }
+  end
 
   let(:connection) { ActiveRecord::Base.connection }
 
@@ -64,7 +65,7 @@ describe 'MakaraPostgreSQLAdapter' do
 
     it 'should send reads to the slave' do
       # ensure the next connection will be the first one
-      connection.slave_pool.strategy.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+      allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
 
       con = connection.slave_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once
@@ -72,6 +73,22 @@ describe 'MakaraPostgreSQLAdapter' do
       connection.execute('SELECT * FROM users')
     end
 
+    it 'should send exists? to slave' do
+      next if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0 # query doesn't work?
+
+      allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
+      Test::User.exists? # flush other (schema) things that need to happen
+      
+      con = connection.slave_pool.connections.first
+      if (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 2) ||
+         (ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 0)
+        expect(con).to receive(:exec_no_cache).with(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/, any_args).once.and_call_original
+      else
+        expect(con).to receive(:exec_query).with(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/, any_args).once.and_call_original
+      end
+      Test::User.exists?
+    end
+
     it 'should send writes to master' do
       con = connection.master_pool.connections.first
       expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')
@@ -175,4 +192,60 @@ describe 'MakaraPostgreSQLAdapter' do
       it_behaves_like 'a transaction supporter'
     end
   end
+
+  context 'with two activerecord connection pools' do
+
+    before :each do
+      class Model1 < ActiveRecord::Base
+      end
+
+      class Model2 < ActiveRecord::Base
+      end
+
+      Model1.establish_connection(config)
+      Model2.establish_connection(config)
+
+    end
+
+    it 'should not leak raw connection into activerecord pool' do
+      # checkout a connection from Model1 pool and remove from the pool
+      conn = Model1.connection_pool.checkout
+      Model1.connection_pool.remove(conn)
+
+      # assign the connection to Model2 pool
+      conn.pool=Model2.connection_pool
+
+      # now close the connection to return it back to the pool
+      conn.close
+
+      # checkout the connection and make sure it is still a makara proxy
+      expect(Model2.connection).to eq(conn)
+    end
+
+    it 'should be able to steal the connection from a different thread' do
+      conn = Model1.connection_pool.checkout
+      conn.steal!
+      expect(conn.owner).to eq(Thread.current)
+      # steal! is not thread safe. it should be done while holding connection pool's mutex
+      t = Thread.new { conn.steal! }
+      t.join
+      expect(conn.owner).to eq(t)
+    end
+
+    it 'should not be able to expire the connection from same thread' do
+      conn = Model2.connection_pool.checkout
+      # expire is not thread safe. it should be done while holding connection pool's mutex
+      expect {
+        t = Thread.new { conn.expire }
+        t.join
+      }.to raise_error(ActiveRecord::ActiveRecordError)
+    end
+
+    it 'should be able to checkin connection back into activerecord pool' do
+      conn = Model1.connection_pool.checkout
+      Model1.connection_pool.checkin(conn)
+      # checkout the connection again and make sure it is same connection
+      expect(Model1.connection).to eq(conn)
+    end
+  end
 end

data/spec/cache_spec.rb

@@ -2,58 +2,8 @@ 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')
-
+  it 'shows a warning' do
+    expect(Makara::Logging::Logger).to receive(:log).with(/Setting the Makara::Cache\.store won't have any effects/, :warn)
     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

@@ -79,7 +79,7 @@ describe Makara::ConfigParser do
 
   end
 
-  it 'should provide an id based on the recursively sorted config' do
+  it 'should provide a default proxy 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)
@@ -88,6 +88,26 @@ describe Makara::ConfigParser do
     expect(parsera.id).to eq(parserc.id)
   end
 
+  it 'should use provided proxy id instead of default' do
+    config_with_custom_id = config.dup
+    config_with_custom_id[:makara][:id] = 'my_proxy'
+
+    parser = described_class.new(config_with_custom_id)
+
+    expect(parser.id).to eq('my_proxy')
+  end
+
+  it 'should replace reserved characters and show a warning for provided proxy ids' do
+    config_with_custom_id = config.dup
+    config_with_custom_id[:makara][:id] = "my|proxy|id:with:reserved:characters"
+    warning = "Proxy id 'my|proxy|id:with:reserved:characters' changed to 'myproxyidwithreservedcharacters'"
+    expect(Makara::Logging::Logger).to receive(:log).with(warning, :warn)
+
+    parser = described_class.new(config_with_custom_id)
+
+    expect(parser.id).to eq('myproxyidwithreservedcharacters')
+  end
+
   context 'master and slave configs' do
     it 'should provide master and slave configs' do
       parser = described_class.new(config)
@@ -97,8 +117,7 @@ describe Makara::ConfigParser do
           :top_level => 'value',
           :sticky => true,
           :blacklist_duration => 30,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         }
       ])
       expect(parser.slave_configs).to eq([
@@ -107,16 +126,14 @@ describe Makara::ConfigParser do
           :top_level => 'value',
           :sticky => true,
           :blacklist_duration => 30,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         },
         {
           :name => 'slave2',
           :top_level => 'value',
           :sticky => true,
           :blacklist_duration => 30,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         }
       ])
     end
@@ -133,8 +150,7 @@ describe Makara::ConfigParser do
           :top_level => 'value',
           :sticky => true,
           :blacklist_duration => 456,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         }
       ])
       expect(parser.slave_configs).to eq([
@@ -143,16 +159,14 @@ describe Makara::ConfigParser do
           :top_level => 'slave value',
           :sticky => true,
           :blacklist_duration => 123,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         },
         {
           :name => 'slave2',
           :top_level => 'value',
           :sticky => true,
           :blacklist_duration => 123,
-          :master_ttl => 5,
-          :sticky => true
+          :master_ttl => 5
         }
       ])
     end