janus-ar 8.0.0 → 8.0.1

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

@@ -1,82 +1,78 @@
-# frozen_string_literal: true
-
-RSpec.describe ActiveRecord::ConnectionAdapters::JanusMysql2Adapter do
-  subject { described_class.new(config) }
-
-  it { expect(described_class::FOUND_ROWS).to eq 'FOUND_ROWS' }
-
-  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
-    describe 'Integration tests' do
-      let(:table_name) { 'table_name_mysql2' }
-
-      it_behaves_like 'a mysql like server'
-    end
-  end
-end
+# 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,82 +1,77 @@
-# frozen_string_literal: true
-
-RSpec.describe ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter do
-  subject { described_class.new(config) }
-
-  it { expect(described_class::FOUND_ROWS).to eq 'FOUND_ROWS' }
-
-  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,
-      'found_rows' => true,
-    }
-  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,
-      'found_rows' => true,
-    }
-  end
-  let(:config) do
-    {
-      database:,
-      adapter: 'janus_trilogy',
-      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).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).symbolize_keys
-      end
-    end
-  end
-
-  describe 'Integration tests' do
-    let(:table_name) { 'table_name_trilogy' }
-
-    it_behaves_like 'a mysql like server'
-  end
-end
+# 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/context_spec.rb

@@ -1,46 +1,118 @@
-# frozen_string_literal: true
-
-require 'janus-ar/context'
-
-RSpec.describe Janus::Context do
-  describe '#initialize' do
-    it 'sets the primary flag and expiry' do
-      context = described_class.new(primary: true, expiry: 60)
-      expect(context.use_primary?).to be true
-      expect(context.last_used_connection).to eq(:primary)
-    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 '#potential_write' do
-    it 'calls stick_to_primary' do
-      context = described_class.new
-      expect(context).to receive(:stick_to_primary)
-      context.potential_write
-    end
-  end
-
-  describe '#release_all' do
-    it 'resets the primary flag and expiry' do
-      context = described_class.new(primary: true, expiry: 60)
-      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(:secondary)
-      expect(context.last_used_connection).to eq(:secondary)
-    end
-  end
-end
+# 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

@@ -0,0 +1,28 @@
+# 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/subscriber_spec.rb

@@ -0,0 +1,58 @@
+# 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