janus-ar 8.0.1 → 8.1.0

data/spec/lib/janus-ar/active_record/connection_adapters/janus_mysql_adapter_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe ActiveRecord::ConnectionAdapters::JanusMysql2Adapter do
-  subject { described_class.new(config) }
-
-  let(:database) { 'test' }
-  let(:primary_config) do
-    {
-      'username' => 'primary',
-      'password' => 'primary_password',
-      'host' => '127.0.0.1',
-      'ssl' => true,
-      'ssl_mode' => 'REQUIRED',
-      'tls_min_version' => 3,
-    }
-  end
-  let(:replica_config) do
-    {
-      'username' => 'replica',
-      'password' => 'replica_password',
-      'host' => '127.0.0.1',
-      'pool' => 500,
-      'ssl' => true,
-      'ssl_mode' => 'REQUIRED',
-      'tls_min_version' => 3,
-    }
-  end
-  let(:config) do
-    {
-      database:,
-      adapter: 'janus_mysql2',
-      janus: {
-        'primary' => primary_config,
-        'replica' => replica_config,
-      },
-    }
-  end
-
-  describe 'Configuration' do
-    it 'creates primary connection as expected' do
-      config = primary_config.dup.freeze
-      expect(subject.config).to eq config.merge('database' => database,
-                                                'flags' => ::Janus::Client::FOUND_ROWS).symbolize_keys
-    end
-
-    it 'creates replica connection as expected' do
-      config = replica_config.dup.freeze
-      expect(
-        subject.replica_connection.instance_variable_get(:@config)
-      ).to eq config.merge('database' => database, 'flags' => ::Janus::Client::FOUND_ROWS).symbolize_keys
-    end
-
-    context 'Rails sets empty database for server connection' do
-      let(:database) { nil }
-
-      it 'creates primary connection as expected' do
-        config = primary_config.dup.freeze
-        expect(subject.config).to eq config.merge(
-          'database' => nil,
-          'flags' => ::Janus::Client::FOUND_ROWS
-        ).symbolize_keys
-      end
-
-      it 'creates replica connection as expected' do
-        config = replica_config.dup.freeze
-        expect(
-          subject.replica_connection.instance_variable_get(:@config)
-        ).to eq config.merge('database' => nil, 'flags' => ::Janus::Client::FOUND_ROWS).symbolize_keys
-      end
-    end
-  end
-
-  describe 'Integration tests' do
-    let(:table_name) { 'table_name_mysql2' }
-
-    it_behaves_like 'a mysql like server'
-  end
-end

data/spec/lib/janus-ar/active_record/connection_adapters/janus_trilogy_adapter_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter do
-  subject { described_class.new(config) }
-
-  let(:database) { 'test' }
-  let(:primary_config) do
-    {
-      'username' => 'primary',
-      'password' => 'primary_password',
-      'host' => '127.0.0.1',
-      'ssl' => true,
-      'ssl_mode' => 'REQUIRED',
-      'tls_min_version' => Trilogy::TLS_VERSION_12,
-    }
-  end
-  let(:replica_config) do
-    {
-      'username' => 'replica',
-      'password' => 'replica_password',
-      'host' => '127.0.0.1',
-      'pool' => 500,
-      'ssl' => true,
-      'ssl_mode' => 'REQUIRED',
-      'tls_min_version' => Trilogy::TLS_VERSION_12,
-    }
-  end
-  let(:config) do
-    {
-      database:,
-      adapter: 'janus_trilogy',
-      janus: {
-        'primary' => primary_config,
-        'replica' => replica_config,
-      },
-    }
-  end
-
-  describe 'Configuration' do
-    # Trilogy enables FOUND_ROWS via the `found_rows` option (not mysql2-style
-    # flags), and ActiveRecord's TrilogyAdapter forces it on. We assert it is
-    # present even though the supplied config omits it.
-    it 'creates primary connection as expected' do
-      config = primary_config.dup.freeze
-      expect(subject.config).to eq config.merge('database' => database, 'found_rows' => true).symbolize_keys
-    end
-
-    it 'creates replica connection as expected' do
-      config = replica_config.dup.freeze
-      expect(
-        subject.replica_connection.instance_variable_get(:@config)
-      ).to eq config.merge('database' => database, 'found_rows' => true).symbolize_keys
-    end
-
-    context 'Rails sets empty database for server connection' do
-      let(:database) { nil }
-
-      it 'creates primary connection as expected' do
-        config = primary_config.dup.freeze
-        expect(subject.config).to eq config.merge('database' => nil, 'found_rows' => true).symbolize_keys
-      end
-
-      it 'creates replica connection as expected' do
-        config = replica_config.dup.freeze
-        expect(
-          subject.replica_connection.instance_variable_get(:@config)
-        ).to eq config.merge('database' => nil, 'found_rows' => true).symbolize_keys
-      end
-    end
-  end
-
-  describe 'Integration tests' do
-    let(:table_name) { 'table_name_trilogy' }
-
-    it_behaves_like 'a mysql like server'
-  end
-end

data/spec/lib/janus-ar/client_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'janus-ar/client'
-
-RSpec.describe Janus::Client do
-  it { expect(described_class::FOUND_ROWS).to eq 2 }
-end

data/spec/lib/janus-ar/context_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'janus-ar/context'
-require 'active_support/executor'
-
-RSpec.describe Janus::Context do
-  after(:each) { described_class.release_all }
-
-  describe '#initialize' do
-    it 'defaults to the replica and a primary last-used connection' do
-      context = described_class.new
-      expect(context.use_primary?).to be false
-      expect(context.last_used_connection).to eq(:primary)
-    end
-
-    it 'can be created pinned to the primary' do
-      expect(described_class.new(primary: true).use_primary?).to be true
-    end
-  end
-
-  describe '#stick_to_primary' do
-    it 'sets the primary flag to true' do
-      context = described_class.new
-      context.stick_to_primary
-      expect(context.use_primary?).to be true
-    end
-  end
-
-  describe '#release_all' do
-    it 'resets the primary flag and the last used connection' do
-      context = described_class.new(primary: true)
-      context.used_connection(:primary)
-      context.release_all
-      expect(context.use_primary?).to be false
-      expect(context.last_used_connection).to be_nil
-    end
-  end
-
-  describe '#used_connection' do
-    it 'sets the last used connection' do
-      context = described_class.new
-      context.used_connection(:replica)
-      expect(context.last_used_connection).to eq(:replica)
-    end
-  end
-
-  describe 'class-level access' do
-    it 'sticks and releases the current execution state' do
-      described_class.stick_to_primary
-      expect(described_class.use_primary?).to be true
-      described_class.release_all
-      expect(described_class.use_primary?).to be false
-    end
-
-    it 'isolates state between threads' do
-      described_class.stick_to_primary
-      other = Thread.new { described_class.use_primary? }.value
-      expect(other).to be false
-      expect(described_class.use_primary?).to be true
-    end
-
-    it 'isolates the last used connection between threads' do
-      described_class.used_connection(:replica)
-      other = Thread.new do
-        described_class.used_connection(:primary)
-        described_class.last_used_connection
-      end.value
-      expect(other).to eq(:primary)
-      expect(described_class.last_used_connection).to eq(:replica)
-    end
-
-    it 'is safe to release a context that was never touched' do
-      Thread.new do
-        expect { described_class.release_all }.not_to raise_error
-        expect(described_class.use_primary?).to be false
-      end.join
-    end
-  end
-
-  describe '.install_reset_hook' do
-    let(:executor) { Class.new(ActiveSupport::Executor) }
-
-    it 'releases the context at the start of every executor run' do
-      described_class.install_reset_hook(executor)
-      described_class.stick_to_primary
-
-      stuck_inside = nil
-      executor.wrap { stuck_inside = described_class.use_primary? }
-
-      expect(stuck_inside).to be false
-    end
-
-    it 'stops stickiness leaking from a previous run into the next' do
-      described_class.install_reset_hook(executor)
-
-      executor.wrap { described_class.stick_to_primary }
-
-      leaked = nil
-      executor.wrap { leaked = described_class.use_primary? }
-      expect(leaked).to be false
-    end
-
-    it 'still starts the next run clean after the previous run raised' do
-      described_class.install_reset_hook(executor)
-
-      expect do
-        executor.wrap do
-          described_class.stick_to_primary
-          raise 'boom'
-        end
-      end.to raise_error('boom')
-
-      leaked = nil
-      executor.wrap { leaked = described_class.use_primary? }
-      expect(leaked).to be false
-    end
-  end
-end

data/spec/lib/janus-ar/db_console_config_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'janus-ar/db_console_config'
-
-RSpec.describe Janus::DbConsoleConfig do
-  subject(:console_config) { described_class.new(db_config) }
-
-  let(:db_config) do
-    instance_double(
-      ActiveRecord::DatabaseConfigurations::HashConfig,
-      configuration_hash: {
-        database: 'my_database',
-        janus: {
-          'primary' => { 'host' => 'primary.local', 'username' => 'primary' },
-          'replica' => { 'host' => 'replica.local', 'username' => 'replica' },
-        },
-      }
-    )
-  end
-
-  it 'exposes the replica configuration with symbol keys so dbconsole connects to a replica' do
-    expect(console_config.configuration_hash).to eq(host: 'replica.local', username: 'replica')
-  end
-
-  it 'exposes the database name from the top-level config' do
-    expect(console_config.database).to eq('my_database')
-  end
-end

data/spec/lib/janus-ar/logging/logger_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Janus::Logging::Logger do
-  describe '.log' do
-    let(:logger) { double('logger') }
-
-    before do
-      described_class.logger = logger
-    end
-
-    it 'logs the message with the specified format' do
-      expect(logger).to receive(:send).with(:info, '[Janus] Test message')
-      described_class.log('Test message', :info)
-    end
-
-    it 'does not log the message if logger is not set' do
-      described_class.logger = nil
-      expect(logger).not_to receive(:send)
-      described_class.log('Test message', :info)
-    end
-  end
-
-  describe '.logger=' do
-    let(:logger) { double('logger') }
-
-    it 'sets the logger' do
-      described_class.logger = logger
-      expect(described_class.logger).to eq(logger)
-    end
-  end
-end

data/spec/lib/janus-ar/logging/subscriber_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'janus-ar/context'
-require 'janus-ar/logging/subscriber'
-
-RSpec.describe Janus::Logging::Subscriber do
-  # A minimal stand-in for ActiveRecord::LogSubscriber: it records the event it
-  # is given so we can assert on the (possibly rewritten) payload name.
-  let(:base_class) do
-    Class.new do
-      attr_reader :received_event
-
-      def sql(event)
-        @received_event = event
-      end
-    end
-  end
-  let(:subscriber) { base_class.new.extend(described_class) }
-  let(:event) { instance_double(ActiveSupport::Notifications::Event, payload: { name: 'User Load' }) }
-
-  after(:each) { Janus::Context.release_all }
-
-  it 'tags the log name with the last used connection' do
-    Janus::Context.used_connection(:replica)
-
-    subscriber.sql(event)
-
-    expect(event.payload[:name]).to eq('[replica] User Load')
-    expect(subscriber.received_event).to eq(event)
-  end
-
-  it 'reflects the primary connection' do
-    Janus::Context.used_connection(:primary)
-
-    subscriber.sql(event)
-
-    expect(event.payload[:name]).to eq('[primary] User Load')
-  end
-
-  it 'leaves the name unchanged when no connection has been used yet' do
-    Janus::Context.release_all
-
-    subscriber.sql(event)
-
-    expect(event.payload[:name]).to eq('User Load')
-  end
-
-  Janus::Logging::Subscriber::IGNORE_PAYLOAD_NAMES.each do |ignored|
-    it "does not tag #{ignored} statements" do
-      Janus::Context.used_connection(:replica)
-      ignored_event = instance_double(ActiveSupport::Notifications::Event, payload: { name: ignored })
-
-      subscriber.sql(ignored_event)
-
-      expect(ignored_event.payload[:name]).to eq(ignored)
-    end
-  end
-end

data/spec/lib/janus-ar/query_director_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Janus::QueryDirector do
-  describe 'Constants' do
-    it { expect(described_class::SQL_SKIP_ALL_MATCHERS).to eq [/\A\s*set\s+local\s/i] }
-    it {
-      expect(described_class::SQL_PRIMARY_MATCHERS).to eq(
-        [
-          /\A\s*select.+for update\Z/i, /select.+lock in share mode\Z/i,
-          /\A\s*select.+(nextval|currval|lastval|get_lock|release_lock|pg_advisory_lock|pg_advisory_unlock)\(/i,
-          /\A\s*show/i
-        ]
-      )
-    }
-    it { expect(described_class::SQL_REPLICA_MATCHERS).to eq([/\A\s*(select|with.+\)\s*select)\s/i]) }
-    it { expect(described_class::SQL_ALL_MATCHERS).to eq([/\A\s*set\s/i]) }
-
-    it { expect(described_class::ALL).to eq :all }
-    it { expect(described_class::REPLICA).to eq :replica }
-    it { expect(described_class::PRIMARY).to eq :primary }
-  end
-
-  describe '#where_to_send?' do
-    let(:open_transactions) { 0 }
-
-    before(:each) { Janus::Context.release_all }
-
-    context 'with reads' do
-      {
-        'plain select' => 'SELECT * FROM users',
-        'lower case select' => 'select * from users',
-        'CTE select' => 'WITH recent AS (SELECT * FROM users) SELECT * FROM recent',
-        'leading whitespace' => "\n\t  SELECT 1",
-      }.each do |label, query|
-        it "routes a #{label} to the replica" do
-          expect(described_class.new(query, 0).where_to_send?).to eq(:replica)
-        end
-      end
-    end
-
-    context 'with writes' do
-      # Every one of these used to be sent to the replica because the router
-      # defaulted unknown statements there. They are genuine writes and must
-      # reach the primary.
-      %w(
-        INSERT UPDATE DELETE REPLACE RENAME CALL LOAD OPTIMIZE ANALYZE REPAIR
-        CREATE DROP TRUNCATE ALTER
-      ).each do |verb|
-        it "routes #{verb} to the primary" do
-          sql = "#{verb} something that is not a read"
-          expect(described_class.new(sql, 0).where_to_send?).to eq(:primary)
-        end
-      end
-
-      it 'routes a write annotated with a leading comment to the primary' do
-        sql = '/* app:web,controller:orders */ INSERT INTO orders (id) VALUES (1)'
-        expect(described_class.new(sql, 0).where_to_send?).to eq(:primary)
-      end
-
-      it 'routes a read annotated with a leading comment to the replica' do
-        sql = '/* app:web */ SELECT * FROM orders'
-        expect(described_class.new(sql, 0).where_to_send?).to eq(:replica)
-      end
-    end
-
-    context 'with comments and whitespace around the statement' do
-      {
-        'a line (--) comment then a read' => "-- audit trail\nSELECT * FROM orders",
-        'a hash (#) comment then a read' => "# cache key\nSELECT * FROM orders",
-        'several stacked leading comments then a read' => "/* a */ /* b */\n\t SELECT 1",
-        'tabs and newlines then a read' => "\n\t  SELECT 1",
-      }.each do |label, query|
-        it "routes #{label} to the replica" do
-          expect(described_class.new(query, 0).where_to_send?).to eq(:replica)
-        end
-      end
-
-      {
-        'a line (--) comment then a write' => "-- triggered by job 42\nUPDATE orders SET state = 1",
-        'a hash (#) comment then a write' => "# backfill\nDELETE FROM orders",
-        'a block comment then a write' => "/* migration */ ALTER TABLE orders ADD COLUMN x INT",
-      }.each do |label, query|
-        it "routes #{label} to the primary" do
-          expect(described_class.new(query, 0).where_to_send?).to eq(:primary)
-        end
-      end
-    end
-
-    context 'with locking reads' do
-      it 'routes SELECT ... FOR UPDATE to the primary' do
-        expect(described_class.new('SELECT * FROM users FOR UPDATE', 0).where_to_send?).to eq(:primary)
-      end
-
-      it 'routes SELECT ... LOCK IN SHARE MODE to the primary' do
-        expect(described_class.new('SELECT * FROM users LOCK IN SHARE MODE', 0).where_to_send?).to eq(:primary)
-      end
-
-      it 'routes advisory lock reads to the primary' do
-        expect(described_class.new("SELECT get_lock('x', 0)", 0).where_to_send?).to eq(:primary)
-      end
-    end
-
-    context 'with SHOW' do
-      it 'routes SHOW statements to the primary' do
-        expect(described_class.new('SHOW TABLES', 0).where_to_send?).to eq(:primary)
-      end
-    end
-
-    context 'with SET' do
-      it 'routes SET to all connections' do
-        expect(described_class.new('SET sql_mode = ?', 0).where_to_send?).to eq(:all)
-      end
-
-      it 'does not broadcast SET LOCAL to all connections' do
-        expect(described_class.new('SET LOCAL sql_mode = ?', 0).where_to_send?).to eq(:primary)
-      end
-    end
-
-    context 'when the context is stuck to the primary' do
-      before(:each) { Janus::Context.stick_to_primary }
-
-      it 'routes an otherwise replica-bound read to the primary' do
-        expect(described_class.new('SELECT * FROM users', 0).where_to_send?).to eq(:primary)
-      end
-    end
-
-    context 'when inside a transaction' do
-      let(:open_transactions) { 1 }
-
-      it 'routes reads to the primary so they can see uncommitted writes' do
-        expect(described_class.new('SELECT * FROM users', open_transactions).where_to_send?).to eq(:primary)
-      end
-    end
-
-    context 'with an unrecognised / empty statement' do
-      it 'defaults blank input to the primary' do
-        expect(described_class.new('   ', 0).where_to_send?).to eq(:primary)
-      end
-    end
-  end
-end