makara 0.5.1 → 0.6.0.pre

data/spec/active_record/connection_adapters/makara_postgis_adapter_spec.rb

@@ -52,16 +52,16 @@ if RUBY_ENGINE == 'ruby' &&
         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)
+      it 'should have one primary and two replicas' do
+        expect(connection.primary_pool.connection_count).to eq(1)
+        expect(connection.replica_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
+        connection.primary_pool.connections.each do |primary|
+          expect(primary).to receive(:execute).never
         end
 
         change_context
@@ -71,28 +71,28 @@ if RUBY_ENGINE == 'ruby' &&
       end
 
       it 'should send SET operations to each connection' do
-        connection.master_pool.connections.each do |con|
+        connection.primary_pool.connections.each do |con|
           expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
         end
 
-        connection.slave_pool.connections.each do |con|
+        connection.replica_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
+      it 'should send reads to the replica' 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
+        con = connection.replica_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
+      it 'should send writes to primary' do
+        con = connection.primary_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
@@ -115,10 +115,10 @@ if RUBY_ENGINE == 'ruby' &&
       end
     end
 
-    context 'with only master connection' do
+    context 'with only primary 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'}
+        custom_config['makara']['connections'].select{|h| h['role'] == 'replica' }.each{|h| h['port'] = '1'}
 
         ActiveRecord::Base.establish_connection(custom_config)
         load(File.dirname(__FILE__) + '/../../support/schema.rb')
@@ -128,14 +128,14 @@ if RUBY_ENGINE == 'ruby' &&
       end
     end
 
-    context 'with only slave connection' do
+    context 'with only replica 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'}
+        custom_config['makara']['connections'].select{|h| h['role'] == 'primary' }.each{|h| h['port'] = '1'}
 
         ActiveRecord::Base.establish_connection(custom_config)
 

data/spec/active_record/connection_adapters/makara_postgresql_adapter_spec.rb

@@ -26,16 +26,16 @@ describe 'MakaraPostgreSQLAdapter' do
       change_context
     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)
+    it 'should have one primary and two replicas' do
+      expect(connection.primary_pool.connection_count).to eq(1)
+      expect(connection.replica_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
+      connection.primary_pool.connections.each do |primary|
+        expect(primary).to receive(:execute).never
       end
 
       change_context
@@ -45,41 +45,43 @@ describe 'MakaraPostgreSQLAdapter' do
     end
 
     it 'should send SET operations to each connection' do
-      connection.master_pool.connections.each do |con|
+      connection.primary_pool.connections.each do |con|
         expect(con).to receive(:execute).with("SET TimeZone = 'UTC'").once
       end
 
-      connection.slave_pool.connections.each do |con|
+      connection.replica_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
+    it 'should send reads to the replica' 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
+      con = connection.replica_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once
 
       connection.execute('SELECT * FROM users')
     end
 
-    it 'should send exists? to slave' do
+    it 'should send exists? to replica' do
       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
+      con = connection.replica_pool.connections.first
 
       expect(con).to receive(:exec_query) do |query|
         expect(query).to match(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/)
-      end.once.and_call_original
+      end.once.
+        # and_call_original # Switch back to this once https://github.com/rspec/rspec-mocks/pull/1385 is released
+        and_wrap_original { |m, *args| m.call(*args.first(3)) }
 
       Test::User.exists?
     end
 
-    it 'should send writes to master' do
-      con = connection.master_pool.connections.first
+    it 'should send writes to primary' do
+      con = connection.primary_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
@@ -95,10 +97,10 @@ describe 'MakaraPostgreSQLAdapter' do
     end
   end
 
-  context 'with only master connection' do
+  context 'with only primary 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'}
+      custom_config['makara']['connections'].select{|h| h['role'] == 'replica' }.each{|h| h['port'] = '1'}
 
       establish_connection(custom_config)
       load(File.dirname(__FILE__) + '/../../support/schema.rb')
@@ -108,14 +110,14 @@ describe 'MakaraPostgreSQLAdapter' do
     end
   end
 
-  context 'with only slave connection' do
+  context 'with only replica connection' do
     it 'should raise error only on write' do
       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'}
+      custom_config['makara']['connections'].select{|h| h['role'] == 'primary' }.each{|h| h['port'] = '1'}
 
       establish_connection(custom_config)
 
@@ -131,13 +133,13 @@ describe 'MakaraPostgreSQLAdapter' do
         load(File.dirname(__FILE__) + '/../../support/schema.rb')
         change_context
 
-        # Pre-loads the attributes so that schema queries don't hit slave
+        # Pre-loads the attributes so that schema queries don't hit replica
         # user = User.create(name: 'hello')
-        connection.slave_pool.connections.each do |slave|
+        connection.replica_pool.connections.each do |replica|
           # Using method missing to help with back trace, literally
-          # no query should be executed on slave once a transaction is opened
-          expect(slave).to receive(:method_missing).never
-          expect(slave).to receive(:execute).never
+          # no query should be executed on replica once a transaction is opened
+          expect(replica).to receive(:method_missing).never
+          expect(replica).to receive(:execute).never
         end
       end
 

data/spec/config_parser_spec.rb

@@ -7,14 +7,14 @@ describe Makara::ConfigParser do
       makara: {
         connections: [
           {
-            role: 'master',
-            name: 'themaster'
+            role: 'primary',
+            name: 'theprimary'
           },
           {
-            name: 'slave1'
+            name: 'replica1'
           },
           {
-            name: 'slave2'
+            name: 'replica2'
           }
         ]
       }
@@ -24,7 +24,7 @@ describe Makara::ConfigParser do
   context '::merge_and_resolve_default_url_config' do
     let(:config_without_url) do
       {
-        master_ttl: 5,
+        primary_ttl: 5,
         blacklist_duration: 30,
         sticky: true,
         adapter: 'mysql2_makara',
@@ -39,7 +39,7 @@ describe Makara::ConfigParser do
 
     let(:config_with_url) do
       {
-        master_ttl: 5,
+        primary_ttl: 5,
         blacklist_duration: 30,
         sticky: true,
         adapter: 'mysql2_makara',
@@ -106,32 +106,32 @@ describe Makara::ConfigParser do
     expect(parser.id).to eq('myproxyidwithreservedcharacters')
   end
 
-  context 'master and slave configs' do
-    it 'should provide master and slave configs' do
+  context 'primary and replica configs' do
+    it 'should provide primary and replica configs' do
       parser = described_class.new(config)
-      expect(parser.master_configs).to eq([
+      expect(parser.primary_configs).to eq([
         {
-          name: 'themaster',
+          name: 'theprimary',
           top_level: 'value',
           sticky: true,
           blacklist_duration: 30,
-          master_ttl: 5
+          primary_ttl: 5
         }
       ])
-      expect(parser.slave_configs).to eq([
+      expect(parser.replica_configs).to eq([
         {
-          name: 'slave1',
+          name: 'replica1',
           top_level: 'value',
           sticky: true,
           blacklist_duration: 30,
-          master_ttl: 5
+          primary_ttl: 5
         },
         {
-          name: 'slave2',
+          name: 'replica2',
           top_level: 'value',
           sticky: true,
           blacklist_duration: 30,
-          master_ttl: 5
+          primary_ttl: 5
         }
       ])
     end
@@ -139,32 +139,32 @@ describe Makara::ConfigParser do
     it 'connection configuration should override makara config' do
       config[:makara][:blacklist_duration] = 123
       config[:makara][:connections][0][:blacklist_duration] = 456
-      config[:makara][:connections][1][:top_level] = 'slave value'
+      config[:makara][:connections][1][:top_level] = 'replica value'
 
       parser = described_class.new(config)
-      expect(parser.master_configs).to eq([
+      expect(parser.primary_configs).to eq([
         {
-          name: 'themaster',
+          name: 'theprimary',
           top_level: 'value',
           sticky: true,
           blacklist_duration: 456,
-          master_ttl: 5
+          primary_ttl: 5
         }
       ])
-      expect(parser.slave_configs).to eq([
+      expect(parser.replica_configs).to eq([
         {
-          name: 'slave1',
-          top_level: 'slave value',
+          name: 'replica1',
+          top_level: 'replica value',
           sticky: true,
           blacklist_duration: 123,
-          master_ttl: 5
+          primary_ttl: 5
         },
         {
-          name: 'slave2',
+          name: 'replica2',
           top_level: 'value',
           sticky: true,
           blacklist_duration: 123,
-          master_ttl: 5
+          primary_ttl: 5
         }
       ])
     end

data/spec/connection_wrapper_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe Makara::ConnectionWrapper do
-  let(:proxy){ FakeProxy.new({makara: {blacklist_duration: 5, connections: [{role: 'master'}, {role: 'slave'}, {role: 'slave'}]}}) }
+  let(:proxy){ FakeProxy.new({makara: {blacklist_duration: 5, connections: [{role: 'primary'}, {role: 'replica'}, {role: 'replica'}]}}) }
   let(:connection){ subject._makara_connection }
 
-  subject{ proxy.master_pool.connections.first }
+  subject{ proxy.primary_pool.connections.first }
 
   it 'should extend the connection with new functionality' do
     expect(connection).to respond_to(:_makara_name)

data/spec/context_spec.rb

@@ -49,7 +49,7 @@ describe Makara::Context do
       Makara::Context.set_current(context_data)
     end
 
-    it 'sticks a proxy to master for the current request' do
+    it 'sticks a proxy to primary for the current request' do
       expect(Makara::Context.stuck?('mariadb')).to be_falsey
 
       Makara::Context.stick('mariadb', 10)

data/spec/middleware_spec.rb

@@ -32,7 +32,7 @@ describe Makara::Middleware do
     _, headers, body = middleware.call(env)
 
     expect(headers).to eq({})
-    expect(body).to eq('slave/1')
+    expect(body).to eq('replica/1')
   end
 
   it 'should use the cookie-provided context if present' do
@@ -41,15 +41,15 @@ describe Makara::Middleware do
     _, headers, body = middleware.call(env)
 
     expect(headers).to eq({})
-    expect(body).to eq('master/1')
+    expect(body).to eq('primary/1')
   end
 
-  it 'should set the cookie if master is used' do
+  it 'should set the cookie if primary is used' do
     env[:query] = 'update users set name = "phil"'
 
     _, headers, body = middleware.call(env)
 
     expect(headers['Set-Cookie']).to eq("#{key}=mock_mysql%3A#{(now + 5).to_f}; path=/; max-age=10; expires=#{(Time.now + 10).httpdate}; secure; HttpOnly")
-    expect(body).to eq('master/1')
+    expect(body).to eq('primary/1')
   end
 end

data/spec/pool_spec.rb

@@ -4,7 +4,7 @@ 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} }
-  let(:master_pool){ Makara::Pool.new('master', proxy) }
+  let(:primary_pool){ Makara::Pool.new('primary', proxy) }
 
   it 'should wrap connections with a ConnectionWrapper as theyre added to the pool' do
     expect(pool.connections).to be_empty
@@ -147,10 +147,10 @@ describe Makara::Pool do
   end
 
   it 'should error out while blacklisted in transaction' do
-    wrapper_a = master_pool.add(pool_config){ FakeConnection.new(open_transactions: 1) }
-    master_pool.add(pool_config){ FakeConnection.new }
+    wrapper_a = primary_pool.add(pool_config){ FakeConnection.new(open_transactions: 1) }
+    primary_pool.add(pool_config){ FakeConnection.new }
     expect {
-      master_pool.provide do |connection|
+      primary_pool.provide do |connection|
         if connection == wrapper_a
           raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
         end
@@ -158,14 +158,14 @@ describe Makara::Pool do
     }.to raise_error(Makara::Errors::BlacklistedWhileInTransaction)
   end
 
-  it 'skips blacklisted connections in master pool when not in transaction' do
-    wrapper_a = master_pool.add(pool_config){ FakeConnection.new(open_transactions: 0) }
-    master_pool.add(pool_config){ FakeConnection.new }
-    master_pool.provide do |connection|
+  it 'skips blacklisted connections in primary pool when not in transaction' do
+    wrapper_a = primary_pool.add(pool_config){ FakeConnection.new(open_transactions: 0) }
+    primary_pool.add(pool_config){ FakeConnection.new }
+    primary_pool.provide do |connection|
       if connection == wrapper_a
         raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
       end
     end
-    10.times{ master_pool.provide{|connection| expect(connection).not_to eq(wrapper_a) } }
+    10.times{ primary_pool.provide{|connection| expect(connection).not_to eq(wrapper_a) } }
   end
 end

data/spec/proxy_spec.rb

@@ -3,82 +3,82 @@ require 'spec_helper'
 describe Makara::Proxy do
   let(:klass){ FakeProxy }
 
-  it 'sets up a master and slave pool no matter the number of connections' do
+  it 'sets up a primary and replica pool no matter the number of connections' do
     proxy = klass.new(config(0, 0))
-    expect(proxy.master_pool).to be_a(Makara::Pool)
-    expect(proxy.slave_pool).to be_a(Makara::Pool)
+    expect(proxy.primary_pool).to be_a(Makara::Pool)
+    expect(proxy.replica_pool).to be_a(Makara::Pool)
 
     proxy = klass.new(config(2, 0))
-    expect(proxy.master_pool).to be_a(Makara::Pool)
-    expect(proxy.slave_pool).to be_a(Makara::Pool)
+    expect(proxy.primary_pool).to be_a(Makara::Pool)
+    expect(proxy.replica_pool).to be_a(Makara::Pool)
 
     proxy = klass.new(config(0, 2))
-    expect(proxy.master_pool).to be_a(Makara::Pool)
-    expect(proxy.slave_pool).to be_a(Makara::Pool)
+    expect(proxy.primary_pool).to be_a(Makara::Pool)
+    expect(proxy.replica_pool).to be_a(Makara::Pool)
 
     proxy = klass.new(config(2, 2))
-    expect(proxy.master_pool).to be_a(Makara::Pool)
-    expect(proxy.slave_pool).to be_a(Makara::Pool)
+    expect(proxy.primary_pool).to be_a(Makara::Pool)
+    expect(proxy.replica_pool).to be_a(Makara::Pool)
   end
 
   it 'instantiates N connections within each pool' do
     proxy = klass.new(config(1, 2))
 
-    expect(proxy.master_pool.connection_count).to eq(1)
-    expect(proxy.slave_pool.connection_count).to eq(2)
+    expect(proxy.primary_pool.connection_count).to eq(1)
+    expect(proxy.replica_pool.connection_count).to eq(2)
   end
 
-  it 'should delegate any unknown method to a connection in the master pool' do
+  it 'should delegate any unknown method to a connection in the primary pool' do
     proxy = klass.new(config(1, 2))
 
-    con = proxy.master_pool.connections.first
+    con = proxy.primary_pool.connections.first
     allow(con).to receive(:irespondtothis){ 'hello!' }
 
     expect(proxy).to respond_to(:irespondtothis)
     expect(proxy.irespondtothis).to eq('hello!')
   end
 
-  describe '#stick_to_master' do
+  describe '#stick_to_primary' do
     let(:proxy) { klass.new(config(1, 2)) }
 
-    it 'should use master if manually forced' do
-      expect(proxy.master_for?('select * from users')).to eq(false)
+    it 'should use primary if manually forced' do
+      expect(proxy.primary_for?('select * from users')).to eq(false)
 
-      proxy.stick_to_master!
+      proxy.stick_to_primary!
 
-      expect(proxy.master_for?('select * from users')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
     end
 
     it 'should persist stickiness by default' do
       now = Time.now
-      proxy.stick_to_master!
+      proxy.stick_to_primary!
 
       next_context = Makara::Context.next
       expect(next_context[proxy.id]).to be >= (now + 5).to_f
 
       proxy = klass.new(config(1, 2))
-      expect(proxy.master_for?('select * from users')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
     end
 
     it 'optionally skips stickiness persistence, so it applies only to the current request' do
       now = Time.now
-      proxy.stick_to_master!(false)
+      proxy.stick_to_primary!(false)
 
-      expect(proxy.master_for?('select * from users')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
       next_context = Makara::Context.next
       expect(next_context).to be_nil # Nothing to persist, so context is empty
 
       proxy = klass.new(config(1, 2))
-      expect(proxy.master_for?('select * from users')).to eq(false)
+      expect(proxy.primary_for?('select * from users')).to eq(false)
     end
 
-    it 'supports a float master_ttl for stickiness duration' do
+    it 'supports a float primary_ttl for stickiness duration' do
       now = Time.now
       config = config(1, 2).dup
-      config[:makara][:master_ttl] = 0.5
+      config[:makara][:primary_ttl] = 0.5
       proxy = klass.new(config)
 
-      proxy.stick_to_master!
+      proxy.stick_to_primary!
 
       next_context = Makara::Context.next
       expect(next_context[proxy.id]).to be >= (now + 0.5).to_f
@@ -93,90 +93,90 @@ describe Makara::Proxy do
       expect(proxy.sticky).to eq(true)
     end
 
-    it 'should provide the slave pool for a read' do
-      expect(proxy.master_for?('select * from users')).to eq(false)
+    it 'should provide the replica pool for a read' do
+      expect(proxy.primary_for?('select * from users')).to eq(false)
     end
 
-    it 'should provide the master pool for a write' do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
+    it 'should provide the primary pool for a write' do
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
     end
 
-    # master is used, it should continue being used for the duration of the context
-    it 'should stick to master once used for a sticky operation' do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      expect(proxy.master_for?('select * from users')).to eq(true)
+    # primary is used, it should continue being used for the duration of the context
+    it 'should stick to primary once used for a sticky operation' do
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
     end
 
-    it 'should not stick to master if stickiness is disabled' do
+    it 'should not stick to primary if stickiness is disabled' do
       proxy.sticky = false
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      expect(proxy.master_for?('select * from users')).to eq(false)
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(false)
     end
 
-    it 'should not stick to master if we are in a without_sticking block' do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
+    it 'should not stick to primary if we are in a without_sticking block' do
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
 
       proxy.without_sticking do
-        expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-        expect(proxy.master_for?('select * from users')).to eq(false)
+        expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+        expect(proxy.primary_for?('select * from users')).to eq(false)
       end
 
-      expect(proxy.master_for?('select * from users')).to eq(true)
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      expect(proxy.master_for?('select * from users')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
     end
 
-    it 'should not stick to master after without_sticking block if there is a write in it' do
-      expect(proxy.master_for?('select * from users')).to eq(false)
+    it 'should not stick to primary after without_sticking block if there is a write in it' do
+      expect(proxy.primary_for?('select * from users')).to eq(false)
 
       proxy.without_sticking do
-        expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-        expect(proxy.master_for?('select * from users')).to eq(false)
+        expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+        expect(proxy.primary_for?('select * from users')).to eq(false)
       end
 
-      expect(proxy.master_for?('select * from users')).to eq(false)
+      expect(proxy.primary_for?('select * from users')).to eq(false)
     end
 
-    it "should not release master if it was stuck in the same request (no context changes yet)" do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      expect(proxy.master_for?('select * from users')).to eq(true)
+    it "should not release primary if it was stuck in the same request (no context changes yet)" do
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
 
       Timecop.travel Time.now + 10 do
-        # master_ttl has passed but we are still in the same request, so current context
+        # primary_ttl has passed but we are still in the same request, so current context
         # is still relevant
-        expect(proxy.master_for?('select * from users')).to eq(true)
+        expect(proxy.primary_for?('select * from users')).to eq(true)
       end
     end
 
-    it 'should release master if all stuck connections are released' do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      expect(proxy.master_for?('select * from users')).to eq(true)
+    it 'should release primary if all stuck connections are released' do
+      expect(proxy.primary_for?('insert into users values (a,b,c)')).to eq(true)
+      expect(proxy.primary_for?('select * from users')).to eq(true)
 
       Makara::Context.release_all
 
-      expect(proxy.master_for?('select * from users')).to eq(false)
+      expect(proxy.primary_for?('select * from users')).to eq(false)
     end
 
-    it 'should use master if all slaves are blacklisted' do
-      allow(proxy.slave_pool).to receive(:completely_blacklisted?){ true }
-      expect(proxy.master_for?('select * from users')).to eq(true)
+    it 'should use primary if all replicas are blacklisted' do
+      allow(proxy.replica_pool).to receive(:completely_blacklisted?){ true }
+      expect(proxy.primary_for?('select * from users')).to eq(true)
     end
 
-    it 'should use master if all slaves become blacklisted as part of the invocation' do
-      allow(proxy.slave_pool).to receive(:next).and_return(nil)
+    it 'should use primary if all replicas become blacklisted as part of the invocation' do
+      allow(proxy.replica_pool).to receive(:next).and_return(nil)
 
       test = double
       expect(test).to receive(:blacklisting).once
-      expect(test).to receive(:using_master).once
+      expect(test).to receive(:using_primary).once
 
       proxy.send(:appropriate_pool, :execute, ['select * from users']) do |pool|
-        if pool == proxy.slave_pool
+        if pool == proxy.replica_pool
           test.blacklisting
           pool.instance_variable_get('@blacklist_errors') << StandardError.new('some connection issue')
           pool.connections.each(&:_makara_blacklist!)
           pool.provide
         else
-          test.using_master
+          test.using_primary
         end
       end
     end
@@ -185,23 +185,23 @@ describe Makara::Proxy do
       proxy.ping
 
       # weird setup to allow for the correct
-      proxy.slave_pool.connections.each(&:_makara_blacklist!)
-      proxy.slave_pool.instance_variable_get('@blacklist_errors') << StandardError.new('some slave connection issue')
-      proxy.master_pool.connections.each(&:_makara_blacklist!)
-      proxy.master_pool.instance_variable_get('@blacklist_errors') << StandardError.new('some master connection issue')
+      proxy.replica_pool.connections.each(&:_makara_blacklist!)
+      proxy.replica_pool.instance_variable_get('@blacklist_errors') << StandardError.new('some replica connection issue')
+      proxy.primary_pool.connections.each(&:_makara_blacklist!)
+      proxy.primary_pool.instance_variable_get('@blacklist_errors') << StandardError.new('some primary connection issue')
 
-      allow(proxy).to receive(:_appropriate_pool).and_return(proxy.slave_pool, proxy.master_pool)
+      allow(proxy).to receive(:_appropriate_pool).and_return(proxy.replica_pool, proxy.primary_pool)
 
       begin
         proxy.send(:appropriate_pool, :execute, ['select * from users']) do |pool|
           pool.provide{|c| c }
         end
       rescue Makara::Errors::AllConnectionsBlacklisted => e
-        expect(e.message).to eq('[Makara/master] All connections are blacklisted -> some master connection issue -> [Makara/slave] All connections are blacklisted -> some slave connection issue')
+        expect(e.message).to eq('[Makara/primary] All connections are blacklisted -> some primary connection issue -> [Makara/replica] All connections are blacklisted -> some replica connection issue')
       end
 
-      proxy.slave_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
-      proxy.master_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
+      proxy.replica_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
+      proxy.primary_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
     end
   end
 end