janus-ar 8.0.0 → 8.1.0

data/.github/workflows/ci.yml

@@ -1,60 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby:
-          - '3.2'
-    name: Ruby ${{ matrix.ruby }}
-    services:
-      mysql:
-        image: mysql:8
-        env:
-          MYSQL_DATABASE: test
-          MYSQL_ROOT_PASSWORD: password
-          MYSQL_USER: test
-          MYSQL_PASSWORD: test_password
-        ports:
-          - 3306:3306
-        options: >-
-          --health-cmd "mysqladmin ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - run: |
-          mysql -e "CREATE USER 'replica'@'%' IDENTIFIED BY 'replica_password';" -u root -p${{ env.MYSQL_PASSWORD || 'password' }} -h 127.0.0.1
-          mysql -e "GRANT SELECT ON test.* TO 'replica'@'%'" -u root -p${{ env.MYSQL_PASSWORD || 'password' }} -h 127.0.0.1
-
-          mysql -e "CREATE USER 'primary'@'%' IDENTIFIED BY 'primary_password';" -u root -p${{ env.MYSQL_PASSWORD || 'password' }} -h 127.0.0.1
-          mysql -e "GRANT ALL PRIVILEGES ON *.* TO 'primary'@'%';" -u root -p${{ env.MYSQL_PASSWORD || 'password' }} -h 127.0.0.1
-          mysql -e "FLUSH PRIVILEGES;" -u root -p${{ env.MYSQL_PASSWORD || 'password' }} -h 127.0.0.1
-      - run: |
-          bundle exec rspec
-        env:
-          MYSQL_HOST: 127.0.0.1
-          RAILS_ENV: test
-  RuboCop:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: '3.2'
-          bundler-cache: true
-      - run: |
-          bundle exec rubocop --parallel --color

data/.github/workflows/publish.yml

@@ -1,25 +0,0 @@
-name: Publish GEM
-
-on:
-  push:
-    tags:
-      - v*
-jobs:
-  push:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: write
-      id-token: write
-
-    steps:
-      # Set up
-      - uses: actions/checkout@v4
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          bundler-cache: true
-          ruby-version: ruby
-
-      # Release
-      - uses: rubygems/release-gem@v1

data/.gitignore

@@ -1,2 +0,0 @@
-janus-ar-*.gem
-.rubocop-*

data/.rspec

@@ -1,3 +0,0 @@
---force-color
---format documentation
---require ./spec/spec_helper.rb

data/.rubocop.yml

@@ -1,26 +0,0 @@
-inherit_from:
-  - https://tech.olioex.com/.support/rubocop-styling-v1.0
-
-require:
-  - rubocop-rails
-
-Style/Documentation:
-  Enabled: false
-
-Rails/Delegate:
-  Enabled: false
-
-Metrics/BlockLength:
-  Exclude:
-    - spec/**/*
-
-Style/GlobalVars:
-  Exclude:
-    - 'spec/**/*'
-
-Naming/FileName:
-  Exclude:
-    - lib/janus-ar.rb
-
-Metrics/AbcSize:
-  Max: 25

data/assets/.gitkeep

@@ -1 +0,0 @@
-

data/bin/release.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-gem build janus-ar.gemspec
-gem push janus-ar-*.gem

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

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

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

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

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

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/query_director_spec.rb

@@ -1,59 +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::WRITE_PREFIXES).to eq %w(INSERT UPDATE DELETE LOCK CREATE GRANT DROP ALTER TRUNCATE BEGIN
-                                                       SAVEPOINT FLUSH)
-    }
-
-    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
-    before(:each) do
-      Janus::Context.release_all
-    end
-
-    context 'when should send to all' do
-      it 'returns :all' do
-        sql = 'SET foo = bar'
-        open_transactions = 0
-        query_director = described_class.new(sql, open_transactions)
-        expect(query_director.where_to_send?).to eq(:all)
-      end
-    end
-
-    context 'when can go to replica' do
-      it 'returns :replica' do
-        sql = 'SELECT * FROM users'
-        open_transactions = 0
-        query_director = described_class.new(sql, open_transactions)
-        expect(query_director.where_to_send?).to eq(:replica)
-      end
-    end
-
-    context 'when should go to primary' do
-      it 'returns :primary' do
-        sql = 'INSERT INTO users (name) VALUES ("John")'
-        open_transactions = 0
-        query_director = described_class.new(sql, open_transactions)
-        expect(query_director.where_to_send?).to eq(:primary)
-      end
-    end
-  end
-end

data/spec/shared_examples/a_mysql_like_server.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-RSpec.shared_examples 'a mysql like server' do
-  let(:create_test_table) { ActiveRecord::Base.connection.execute("CREATE TABLE `#{table_name}` (id INT);") }
-
-  before(:each) do
-    $query_logger.flush_all
-    ActiveRecord::Base.establish_connection(config)
-  end
-
-  after(:each) do
-    ActiveRecord::Base.connection.execute(<<-SQL
-      SELECT CONCAT('DROP TABLE IF EXISTS `', table_name, '`;')
-      FROM information_schema.tables
-      WHERE table_schema = '#{database}';
-      SQL
-                                         ).to_a.map { |row| ActiveRecord::Base.connection.execute(row[0]) }
-  end
-
-  it 'can list tables' do
-    expect(ActiveRecord::Base.connection.execute('SHOW TABLES;').to_a).to eq []
-  end
-
-  it 'can create table' do
-    create_test_table
-    expect(ActiveRecord::Base.connection.execute('SHOW TABLES;').to_a).to eq [[table_name]]
-  end
-
-  describe 'SELECT' do
-    it 'reads from `replica` by default' do
-      create_test_table
-      Janus::Context.release_all
-      $query_logger.flush_all
-      ActiveRecord::Base.connection.execute("SELECT * FROM `#{table_name}`;")
-      expect($query_logger.queries.first).to include '[replica]'
-    end
-
-    it 'will read from primary after a write operation' do
-      create_test_table
-      $query_logger.flush_all
-      ActiveRecord::Base.connection.execute("SELECT * FROM `#{table_name}`;")
-      expect($query_logger.queries.first).to include '[primary]'
-    end
-  end
-
-  describe 'INSERT' do
-    let(:insert_query) { "INSERT INTO `#{table_name}` SET `id` = 5;" }
-
-    before(:each) do
-      create_test_table
-      $query_logger.flush_all
-      Janus::Context.release_all
-    end
-
-    it 'sends INSERT query to primary' do
-      ActiveRecord::Base.connection.execute(insert_query)
-      expect($query_logger.queries.first).to include '[primary]'
-    end
-
-    it 'ignores case when directing queries' do
-      ActiveRecord::Base.connection.execute(insert_query.downcase)
-      expect($query_logger.queries.first).to include '[primary]'
-    end
-  end
-
-  describe 'UPDATE' do
-    before(:each) do
-      create_test_table
-      5.times { |i| ActiveRecord::Base.connection.execute("INSERT INTO `#{table_name}` SET `id` = #{i};") }
-      $query_logger.flush_all
-      Janus::Context.release_all
-    end
-
-    it 'continues to direct after bulk update' do
-      ActiveRecord::Base.connection.execute("UPDATE `#{table_name}` SET `id` = `id` + 2;")
-      expect($query_logger.queries.first).to include '[primary]'
-      expect(Janus::Context.last_used_connection).to eq :primary
-      ActiveRecord::Base.connection.execute("SELECT * FROM `#{table_name}`;")
-      expect($query_logger.queries.last).to include '[primary]'
-      Janus::Context.release_all
-      ActiveRecord::Base.connection.execute("SELECT * FROM `#{table_name}`;")
-      expect($query_logger.queries.last).to include '[replica]'
-      expect(Janus::Context.last_used_connection).to eq :replica
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'pry'
-
-require 'active_record'
-
-require './lib/janus-ar'
-require './lib/janus-ar/active_record/connection_adapters/janus_mysql2_adapter'
-require './lib/janus-ar/active_record/connection_adapters/janus_trilogy_adapter'
-
-ActiveRecord::ConnectionAdapters.register("janus_trilogy", "ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter")
-ActiveRecord::ConnectionAdapters.register("janus_mysql2", "ActiveRecord::ConnectionAdapters::JanusMysql2Adapter")
-
-require './spec/shared_examples/a_mysql_like_server.rb'
-
-class QueryLogger
-  def initialize
-    @_logs = []
-  end
-
-  def flush_all
-    @_logs = []
-  end
-
-  def log(level, message)
-    @_logs << "#{level}: #{message}"
-  end
-
-  def error(message)
-    log('error', message)
-  end
-
-  def queries
-    @_logs
-  end
-
-  def debug?
-    true
-  end
-
-  def debug(message)
-    log('debug', message)
-  end
-end
-
-$query_logger = ActiveRecord::Base.logger = QueryLogger.new