octoshark 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f85ce710bd85c0dbfebb2c5eef56c15df187261
-  data.tar.gz: 65a8ee327c29c51b51c062e8adecbff951d382b5
+  metadata.gz: 7a5b422e9a70b5d3ea461f8f1d60d00fdf95fcc2
+  data.tar.gz: 67b85692596f3c3414239b4820a0415e40c09af4
 SHA512:
-  metadata.gz: 00f549a2766e0d417746d7cb3b90c7e83d104891d5611795493d5388e50d6d0816de5f92b9abddb40e208ddf5dd539fea44a57bd293d82707275f641d08b93d7
-  data.tar.gz: d629c9207dd790baf07fe66e57a0f489b1bf364ce4257fa5385f28a8fd7debfdbd805bd69bf7c32eb29d64ffa859dd16e482fe4a3cccfd598e50df233fdf182f
+  metadata.gz: 41d351c20e433d40caa1f3e1888360911a8440a03aeded1092d618b78b91febbf6f3a8cdffc8e537ee6cf482d017500a495019191902a6f77904c165c236e099
+  data.tar.gz: a1f0f8e84cd69a8445e5ce0e6c9abcb53ac1a9b144d7141f8e36ea3596a2ec15c639a6515da9df8554f3e37066aa3368bae76794d2b990ed88ca542b197a96ed

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change log
 
+## 0.2.2 2016-11-09
+
+- Fix `alias_method_chain` deprecation in Rails 5
+
 ## 0.2.1 2016-09-09
 
 - Add support for Rails 5 and Rails 3

data/README.md

@@ -163,7 +163,7 @@ When using `Octoshark::ConnectionPoolsManager`, whenever ActiveRecord::Base call
 
 ## Cleaning test databases
 
-When using persistent connections, you can use tools like [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) or [DatabaseRewinder](https://github.com/amatsuda/database_rewinder) to clean test databases. Here's an example of RSpec config for `DatabaseCleaner`:
+For `Octoshark::ConnectionPoolsManager`, we can use [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) and RSpec like:
 
 ```ruby
 config.before(:suite) do
@@ -177,7 +177,6 @@ config.before(:each) do
 end
 
 config.after(:each) do
-  setup_database_cleaner
   DatabaseCleaner.clean_with(:transaction)
 end
 
@@ -191,49 +190,93 @@ def setup_database_cleaner
 end
 ```
 
-When using non-persistent connections where transaction rollback as a cleaning strategy will not work, we can use a custom solution inspired by `DatabaseRewinder`. It also works with dynamic databases created on the fly in the test suite.
+For `Octoshark::ConnectionManager` where connections and databases are dynamically created and cannot be configured in the test setup, we can write a custom database cleaner inspired by [DatabaseRewinder](https://github.com/amatsuda/database_rewinder). The example below is for a multi-tenant test setup with a main (core) database and a tenant database for the `CURRENT_USER` in the test suite. `CustomDatabaseCleaner.clean_all` cleans all core database tables before test suite and `CustomDatabaseCleaner.clean` cleans used tables in both core and tenant databases after each test.
+
 
 ```ruby
-module DatabaseCleaner
-  module InsertRecorder
-    def execute(sql, *)
-      DatabaseCleaner.record_inserted_table(self, sql)
-      super
+module CustomDatabaseCleaner
+  INSERT_REGEX = /\AINSERT(?:\s+IGNORE)?\s+INTO\s+(?:\.*[`"]?(?<table>[^.\s`"]+)[`"]?)*/i
+
+  @@tables_with_inserts = []
+
+  class << self
+    def record_inserted_table(connection, sql)
+      match = sql.match(INSERT_REGEX)
+
+      if match && match[:table] && tables_with_inserts.exclude?(match[:table])
+        tables_with_inserts << match[:table]
+      end
     end
 
-    def exec_query(sql, *)
-      DatabaseCleaner.record_inserted_table(self, sql)
-      super
+    def clean_all
+      with_core_db_connection do |connection|
+        clean_tables(connection)
+      end
+
+      reset_tables_with_inserts
     end
-  end
 
-  @@tables = []
+    def clean
+      with_core_db_connection do |connection|
+        clean_tables(connection, { 'users' => [CURRENT_USER.id] })
+      end
 
-  def self.tables
-    @@tables
-  end
+      CURRENT_USER.with_tenant do |connection|
+        clean_tables(connection)
+      end
 
-  def self.record_inserted_table(connection, sql)
-    match = sql.match(/\AINSERT(?:\s+IGNORE)?\s+INTO\s+(?:\.*[`"]?([^.\s`"]+)[`"]?)*/i)
-    tables << match[1] if match && !tables.include?(match[1])
-  end
+      reset_tables_with_inserts
+    end
 
-  def self.clean
-    CoreDB.with_connection do |connection|
-      (
-        connection.tables.reject { |t| t == ActiveRecord::Migrator.schema_migrations_table_name } & tables
-      ).each do |table|
+    private
+    def with_core_db_connection(&block)
+      CoreDBManager.with_connection(ActiveRecord::Base.configurations[Rails.env].symbolize_keys, &block)
+    end
+
+    def clean_tables(connection, keep_data = {})
+      tables_to_clean = connection.tables.reject { |t| t == ActiveRecord::Migrator.schema_migrations_table_name }
+      tables_to_clean = tables_to_clean & tables_with_inserts if tables_with_inserts.present?
+
+      tables_to_clean.each do |table|
         connection.disable_referential_integrity do
-          connection.execute "DELETE FROM #{connection.quote_table_name(table)};"
+          table_name = connection.quote_table_name(table)
+          keep_ids   = keep_data[table]
+
+          if keep_ids
+            connection.execute("DELETE FROM #{table_name} WHERE id NOT IN (#{keep_ids.join(',')});")
+          else
+            connection.execute("DELETE FROM #{table_name};")
+          end
         end
       end
     end
-    @@tables = []
+
+    def reset_tables_with_inserts
+      @@tables_with_inserts = []
+    end
+
+    def tables_with_inserts
+      @@tables_with_inserts
+    end
+  end
+end
+
+module CustomDatabaseCleaner
+  module InsertRecorder
+    def execute(sql, *)
+      CustomDatabaseCleaner.record_inserted_table(self, sql)
+      super
+    end
+
+    def exec_query(sql, *)
+      CustomDatabaseCleaner.record_inserted_table(self, sql)
+      super
+    end
   end
 end
 
 require 'active_record/connection_adapters/abstract_mysql_adapter'
-ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:prepend, DatabaseCleaner::InsertRecorder)
+ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:prepend, CustomDatabaseCleaner::InsertRecorder)
 ```
 
 

data/Rakefile

@@ -10,9 +10,9 @@ task :default => :spec
 
 namespace :db do
   task :establish_connection do
-    configs    = YAML.load_file('spec/support/config.yml').with_indifferent_access
-    config     = configs[:db1].except(:database)
-    @databases = configs.map { |_, config| config[:database] }
+    configs    = YAML.load_file('spec/support/config.yml')
+    config     = configs['db1'].reject { |k, v| k == 'database' }
+    @databases = configs.map { |_, config| config['database'] }
     ActiveRecord::Base.establish_connection(config)
   end
 

data/lib/octoshark/active_record_extensions.rb

@@ -1,43 +1,31 @@
 module Octoshark
-  module ActiveRecordBase
-    extend ActiveSupport::Concern
-
-    included do
-      class << self
-        alias_method_chain :establish_connection, :octoshark
-      end
-    end
-
-    module ClassMethods
-      # When a connection is established in an ancestor process that must have
-      # subsequently forked, ActiveRecord establishes a new connection because
-      # it can't reuse the existing one. When that happens, we need to reconnect
-      # Octoshark connection managers.
-      def establish_connection_with_octoshark(*args)
-        establish_connection_without_octoshark(*args)
-        Octoshark::ConnectionPoolsManager.reset_connection_managers!
-      end
+  module ConnectionHandler
+    def establish_connection(*args)
+      Octoshark::ConnectionPoolsManager.reset_connection_managers!
+      super(*args)
     end
   end
 
   module ActiveRecordAbstractAdapter
-    extend ActiveSupport::Concern
-
     attr_accessor :connection_name, :database_name
 
-    included do
-      alias_method_chain :log, :octoshark
-    end
-
-    def log_with_octoshark(sql, name = "SQL", *other_args, &block)
+    def log(sql, name = "SQL", *other_args, &block)
       if connection_name || database_name
         name = "[Octoshark: #{[connection_name, database_name].compact.join(' ')}] #{name}"
       end
 
-      log_without_octoshark(sql, name, *other_args, &block)
+      super(sql, name, *other_args, &block)
     end
   end
 end
 
-ActiveRecord::Base.send(:include, Octoshark::ActiveRecordBase)
-ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, Octoshark::ActiveRecordAbstractAdapter)
+if defined?(ActiveRecord::ConnectionAdapters::ConnectionHandler)
+  # Rails 3.2, 4.0, 4.1, 4.2, 5.0
+  ActiveRecord::ConnectionAdapters::ConnectionHandler.send(:prepend, Octoshark::ConnectionHandler)
+else
+  # Rails 3.0 and 3.1 does not lazy load
+  require 'active_record/connection_adapters/abstract_adapter'
+  ActiveRecord::ConnectionAdapters::ConnectionHandler.send(:prepend, Octoshark::ConnectionHandler)
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, Octoshark::ActiveRecordAbstractAdapter)

data/lib/octoshark/connection_pools_manager.rb

@@ -11,7 +11,7 @@ module Octoshark
     end
 
     def self.reset_connection_managers!
-      connection_managers.map(&:reset!)
+      connection_managers.each(&:reset!)
     end
 
     def self.disconnect!

data/lib/octoshark/version.rb

@@ -1,3 +1,3 @@
 module Octoshark
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: octoshark
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Dalibor Nasevic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-09 00:00:00.000000000 Z
+date: 2016-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -181,4 +181,3 @@ test_files:
 - spec/support/config.yml.template
 - spec/support/config.yml.travis
 - spec/support/helpers.rb
-has_rdoc: