switchman 1.5.13 → 2.0.9

data/lib/switchman/database_server.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
 module Switchman
   class DatabaseServer
     attr_accessor :id
 
     class << self
+      attr_accessor :creating_new_shard
+
       def all
         database_servers.values
       end
@@ -36,8 +42,14 @@ module Switchman
       def database_servers
         unless @database_servers
           @database_servers = {}.with_indifferent_access
-          ::ActiveRecord::Base.configurations.each do |(id, config)|
-            @database_servers[id] = DatabaseServer.new(id, config)
+          if ::Rails.version >= '6.0'
+            ::ActiveRecord::Base.configurations.configurations.each do |config|
+              @database_servers[config.env_name] = DatabaseServer.new(config.env_name, config.config)
+            end
+          else
+            ::ActiveRecord::Base.configurations.each do |(id, config)|
+              @database_servers[id] = DatabaseServer.new(id, config)
+            end
           end
         end
         @database_servers
@@ -59,12 +71,12 @@ module Switchman
       @fake
     end
 
-    def config(environment = :master)
+    def config(environment = :primary)
       @configs[environment] ||= begin
         if @config[environment].is_a?(Array)
           @config[environment].map do |config|
             config = @config.merge((config || {}).symbolize_keys)
-            # make sure Shackles doesn't get any brilliant ideas about choosing the first possible server
+            # make sure GuardRail doesn't get any brilliant ideas about choosing the first possible server
             config.delete(environment)
             config
           end
@@ -76,33 +88,33 @@ module Switchman
       end
     end
 
-    def shackles_environment
-      @shackles_environment || ::Shackles.environment
+    def guard_rail_environment
+      @guard_rail_environment || ::GuardRail.environment
     end
 
     # locks this db to a specific environment, except for
     # when doing writes (then it falls back to the current
-    # value of Shackles.environment)
-    def shackle!(environment = :slave)
-      @shackles_environment = environment
+    # value of GuardRail.environment)
+    def guard!(environment = :secondary)
+      @guard_rail_environment = environment
     end
 
-    def unshackle!
-      @shackles_environment = nil
+    def unguard!
+      @guard_rail_environment = nil
     end
 
-    def unshackle
-      old_env = @shackles_environment
-      unshackle!
+    def unguard
+      old_env = @guard_rail_environment
+      unguard!
       yield
     ensure
-      shackle!(old_env)
+      guard!(old_env)
     end
 
     def shareable?
       @shareable_environment_key ||= []
-      environment = shackles_environment
-      explicit_user = ::Shackles.global_config[:username]
+      environment = guard_rail_environment
+      explicit_user = ::GuardRail.global_config[:username]
       return @shareable if @shareable_environment_key == [environment, explicit_user]
       @shareable_environment_key = [environment, explicit_user]
       if explicit_user
@@ -112,7 +124,7 @@ module Switchman
         config = config.first if config.is_a?(Array)
         username = config[:username]
       end
-      @shareable = self.config[:adapter] != 'sqlite3' && username !~ /%?\{[a-zA-Z0-9_]+\}/
+      @shareable = username !~ /%?\{[a-zA-Z0-9_]+\}/
     end
 
     def shards
@@ -134,31 +146,16 @@ module Switchman
       create_schema = options[:schema]
       # look for another shard associated with this db
       other_shard = self.shards.where("name<>':memory:' OR name IS NULL").order(:id).first
-      temp_name = other_shard.try(:name) unless id == ::Rails.env
-      temp_name = Shard.default.name if id == ::Rails.env
 
       case config[:adapter]
         when 'postgresql'
-          temp_name ||= 'public'
           create_statement = lambda { "CREATE SCHEMA #{name}" }
           password = " PASSWORD #{::ActiveRecord::Base.connection.quote(config[:password])}" if config[:password]
-        when 'sqlite3'
-          if name
-            # Try to create a db on-disk even if the only shards for sqlite are in-memory
-            temp_name = nil if temp_name == ':memory:'
-            # Put it in the db directory if there are no other sqlite shards
-            temp_name ||= 'db/dummy'
-            temp_name = File.join(File.dirname(temp_name), "#{name}.sqlite3")
-            # If they really asked for :memory:, give them :memory:
-            temp_name = name if name == ':memory:'
-            name = temp_name
-          end
         else
-          temp_name ||= self.config[:database] % self.config
           create_statement = lambda { "CREATE DATABASE #{name}" }
       end
       sharding_config = Switchman.config
-      config_create_statement = sharding_config[config[:adapter]].try(:[], :create_statement)
+      config_create_statement = sharding_config[config[:adapter]]&.[](:create_statement)
       config_create_statement ||= sharding_config[:create_statement]
       if config_create_statement
         create_commands = Array(config_create_statement).dup
@@ -168,42 +165,49 @@ module Switchman
       end
 
       create_shard = lambda do
-        shard = Shard.create!(:name => temp_name,
-                            :database_server => self) do |shard|
-          shard.id = options[:id] if options[:id]
+        shard_id = options.fetch(:id) do
+          case config[:adapter]
+            when 'postgresql'
+              id_seq = Shard.connection.quote(Shard.connection.quote_table_name('switchman_shards_id_seq'))
+              next_id = Shard.connection.select_value("SELECT nextval(#{id_seq})")
+              next_id.to_i
+            else
+              nil
+          end
+        end
+
+        if name.nil?
+          base_name = self.config[:database].to_s % self.config
+          base_name = nil if base_name == ':memory:'
+          base_name << '_' if base_name
+          base_id = shard_id || SecureRandom.uuid
+          name = "#{base_name}shard_#{base_id}"
         end
+
+        shard = Shard.create!(:id => shard_id,
+                              :name => name,
+                              :database_server => self)
+        schema_already_existed = false
+
         begin
-          if name.nil?
-            base_name = self.config[:database] % self.config
-            base_name = $1 if base_name =~ /(?:.*\/)(.+)_shard_\d+(?:\.sqlite3)?$/
-            base_name = nil if base_name == ':memory:'
-            base_name << '_' if base_name
-            name = "#{base_name}shard_#{shard.id}"
-            if config[:adapter] == 'sqlite3'
-              # Try to create a db on-disk even if the only shards for sqlite are in-memory
-              temp_name = nil if temp_name == ':memory:'
-              # Put it in the db directory if there are no other sqlite shards
-              temp_name ||= 'db/dummy'
-              name = File.join(File.dirname(temp_name), "#{name}.sqlite3")
-              shard.name = name
-            end
-          end
+          self.class.creating_new_shard = true
           shard.activate(*Shard.categories) do
-            ::Shackles.activate(:deploy) do
+            ::GuardRail.activate(:deploy) do
               begin
                 if create_statement
+                  if (::ActiveRecord::Base.connection.select_value("SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}"))
+                    schema_already_existed = true
+                    raise "This schema already exists; cannot overwrite"
+                  end
                   Array(create_statement.call).each do |stmt|
                     ::ActiveRecord::Base.connection.execute(stmt)
                   end
                   # have to disconnect and reconnect to the correct db
-                  shard.name = name
                   if self.shareable? && other_shard
                     other_shard.activate { ::ActiveRecord::Base.connection }
                   else
                     ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
                   end
-                else
-                  shard.name = name
                 end
                 old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {} if config[:adapter] == 'postgresql'
                 old_verbose = ::ActiveRecord::Migration.verbose
@@ -211,7 +215,10 @@ module Switchman
 
                 unless create_schema == false
                   reset_column_information
-                  migrate = -> { ::ActiveRecord::Migrator.migrate(::ActiveRecord::Migrator.migrations_paths) }
+
+                  migrate = ::Rails.version >= '5.2' ?
+                    -> { ::ActiveRecord::Base.connection.migration_context.migrate } :
+                    -> { ::ActiveRecord::Migrator.migrate(::ActiveRecord::Migrator.migrations_paths) }
                   if ::ActiveRecord::Base.connection.supports_ddl_transactions?
                     ::ActiveRecord::Base.connection.transaction(requires_new: true, &migrate)
                   else
@@ -226,13 +233,16 @@ module Switchman
               end
             end
           end
-          shard.save!
           shard
         rescue
           shard.destroy
-          shard.drop_database if shard.name == name rescue nil
+          unless schema_already_existed
+            shard.drop_database rescue nil
+          end
           reset_column_information unless create_schema == false rescue nil
           raise
+        ensure
+          self.class.creating_new_shard = false
         end
       end
 
@@ -272,7 +282,9 @@ module Switchman
 
     def primary_shard
       unless instance_variable_defined?(:@primary_shard)
-        @primary_shard = shards.where(name: nil).first
+        # if sharding isn't fully set up yet, we may not be able to query the shards table
+        @primary_shard = Shard.default if Shard.default.database_server == self
+        @primary_shard ||= shards.where(name: nil).first
       end
       @primary_shard
     end

data/lib/switchman/default_shard.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'switchman/database_server'
 
 module Switchman
   class DefaultShard
     def id; 'default'; end
+    alias cache_key id
     def activate(*categories); yield; end
     def activate!(*categories); end
     def default?; true; end

data/lib/switchman/engine.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Switchman
   class Engine < ::Rails::Engine
     isolate_namespace Switchman
 
-    config.autoload_once_paths << File.expand_path(File.join(__FILE__, "../../../app/models"))
+    config.autoload_once_paths << File.expand_path("app/models", config.paths.path)
 
     def self.lookup_stores(cache_store_config)
       result = {}
@@ -72,6 +74,7 @@ module Switchman
         require "switchman/active_record/connection_pool"
         require "switchman/active_record/finder_methods"
         require "switchman/active_record/log_subscriber"
+        require "switchman/active_record/migration"
         require "switchman/active_record/model_schema"
         require "switchman/active_record/persistence"
         require "switchman/active_record/predicate_builder"
@@ -80,81 +83,77 @@ module Switchman
         require "switchman/active_record/reflection"
         require "switchman/active_record/relation"
         require "switchman/active_record/spawn_methods"
-        require "switchman/active_record/where_clause_factory"
+        require "switchman/active_record/statement_cache"
         require "switchman/active_record/type_caster"
+        require "switchman/active_record/where_clause_factory"
         require "switchman/arel"
+        require "switchman/call_super"
         require "switchman/rails"
-        require "switchman/shackles/relation"
-        require "switchman/shard_internal"
+        require "switchman/guard_rail/relation"
+        require_dependency "switchman/shard"
+        require "switchman/standard_error"
+
+        ::StandardError.include(StandardError)
 
         include ActiveRecord::Base
         include ActiveRecord::AttributeMethods
         include ActiveRecord::Persistence
         singleton_class.prepend ActiveRecord::ModelSchema::ClassMethods
 
-        if ::Rails.version > '4.2'
-          require "switchman/active_record/statement_cache"
-          ::ActiveRecord::StatementCache.prepend(ActiveRecord::StatementCache)
-          ::ActiveRecord::StatementCache.singleton_class.prepend(ActiveRecord::StatementCache::ClassMethods)
-          ::ActiveRecord::StatementCache::BindMap.prepend(ActiveRecord::StatementCache::BindMap)
-          ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
+        ::ActiveRecord::StatementCache.prepend(ActiveRecord::StatementCache)
+        ::ActiveRecord::StatementCache.singleton_class.prepend(ActiveRecord::StatementCache::ClassMethods)
+        ::ActiveRecord::StatementCache::BindMap.prepend(ActiveRecord::StatementCache::BindMap)
+        ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
 
-          ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
-        end
+        ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
 
-        if ::Rails.version >= '4.1.15'
-          ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
-        end
+        ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
 
-        if ::Rails.version > '4.1'
-          prepend(ActiveRecord::AutosaveAssociation)
-        end
+        prepend(ActiveRecord::AutosaveAssociation)
 
         ::ActiveRecord::Associations::Association.prepend(ActiveRecord::Association)
         ::ActiveRecord::Associations::BelongsToAssociation.prepend(ActiveRecord::BelongsToAssociation)
         ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::CollectionProxy)
-        if ::Rails.version < '5'
-          ::ActiveRecord::Associations::Builder::CollectionAssociation.include(ActiveRecord::Builder::CollectionAssociation)
-        end
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Preloader::Association)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
         ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
-        # when we call super in Switchman::ActiveRecord::QueryCache#select_all,
-        # we want it to find the definition from
-        # ActiveRecord::ConnectionAdapters::DatabaseStatements, not
-        # ActiveRecord::ConnectionAdapters::QueryCache
-        ::ActiveRecord::ConnectionAdapters::QueryCache.send(:remove_method, :select_all)
 
         ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
+        ::ActiveRecord::Migration.prepend(ActiveRecord::Migration)
+        ::ActiveRecord::Migration::Compatibility::V5_0.prepend(ActiveRecord::Migration::Compatibility::V5_0)
+        ::ActiveRecord::MigrationContext.prepend(ActiveRecord::MigrationContext) if ::Rails.version >= '5.2'
+        ::ActiveRecord::Migrator.prepend(ActiveRecord::Migrator)
+
+        ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
+        ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
+        ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationReflection)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Batches)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Calculations)
         ::ActiveRecord::Relation.include(ActiveRecord::FinderMethods)
         ::ActiveRecord::Relation.include(ActiveRecord::QueryMethods)
+        ::ActiveRecord::Relation.prepend(GuardRail::Relation)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Relation)
         ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
-        ::ActiveRecord::Relation.prepend(Shackles::Relation)
+        ::ActiveRecord::Relation.include(CallSuper)
 
-        if ::Rails.version >= '5'
-          ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
-          ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
-          ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
-          ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
-        end
+        ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
+        ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+        ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
+        ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
 
         ::Rails.singleton_class.prepend(Rails::ClassMethods)
 
         ::Arel::Table.prepend(Arel::Table)
         ::Arel::Visitors::ToSql.prepend(Arel::Visitors::ToSql)
-        ::Arel::Visitors::PostgreSQL.include(Arel::Visitors::PostgreSQL) if ::Rails.version < '4.2'
       end
     end
 
-    def self.foreign_key_check(name, type, options)
-      if name.to_s =~ /_id\z/ && type.to_s == 'integer' && options[:limit].to_i < 8
+    def self.foreign_key_check(name, type, limit: nil)
+      if name.to_s =~ /_id\z/ && type.to_s == 'integer' && limit.to_i < 8
         puts "WARNING: All foreign keys need to be 8-byte integers. #{name} looks like a foreign key. If so, please add the option: `:limit => 8`"
       end
     end
@@ -172,6 +171,12 @@ module Switchman
           require "switchman/active_record/postgresql_adapter"
           ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)
         end
+
+        # If Switchman::Shard wasn't loaded as of when ActiveRecord::Base initialized
+        # establish a connection here instead
+        if !Shard.instance_variable_get(:@default)
+          ::ActiveRecord::Base.establish_connection
+        end
       end
     end
 
@@ -182,15 +187,15 @@ module Switchman
       end
     end
 
-    initializer 'switchman.extend_shackles', :before => "switchman.extend_ar" do
+    initializer 'switchman.extend_guard_rail', :before => "switchman.extend_ar" do
       ::ActiveSupport.on_load(:active_record) do
-        require "switchman/shackles"
+        require "switchman/guard_rail"
 
-        ::Shackles.singleton_class.prepend(Shackles::ClassMethods)
+        ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
       end
     end
 
-    initializer 'switchman.extend_controller', :after => "shackles.extend_ar" do
+    initializer 'switchman.extend_controller', :after => "guard_rail.extend_ar" do
       ::ActiveSupport.on_load(:action_controller) do
         require "switchman/action_controller/caching"
 

data/lib/switchman/environment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'etc'
 
 module Switchman

data/lib/switchman/errors.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module Switchman
   class NonExistentShardError < RuntimeError; end
+  class ParallelShardExecError < RuntimeError; end
 end

data/lib/switchman/{shackles → guard_rail}/relation.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Switchman
-  module Shackles
+  module GuardRail
     module Relation
       def exec_queries(*args)
         if self.lock_value
           db = Shard.current(shard_category).database_server
-          if ::Shackles.environment != db.shackles_environment
-            return db.unshackle { super }
+          if ::GuardRail.environment != db.guard_rail_environment
+            return db.unguard { super }
           end
         end
         super
@@ -15,8 +17,8 @@ module Switchman
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*args)
             db = Shard.current(shard_category).database_server
-            if ::Shackles.environment != db.shackles_environment
-              db.unshackle { super }
+            if ::GuardRail.environment != db.guard_rail_environment
+              db.unguard { super }
             else
               super
             end

data/lib/switchman/{shackles.rb → guard_rail.rb}

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Switchman
-  module Shackles
+  module GuardRail
     module ClassMethods
       def self.prepended(klass)
         klass.send(:remove_method, :ensure_handler)
       end
 
       # drops the save_handler and ensure_handler calls from the vanilla
-      # Shackles' implementation.
+      # GuardRail' implementation.
       def activate!(environment)
-        environment ||= :master
+        environment ||= :primary
         activated_environments << environment
         old_environment = self.environment
-        @environment = environment
+        Thread.current[:guard_rail_environment] = environment
         old_environment
       end
 

data/lib/switchman/open4.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'open4'
+
+# This fixes a bug with exception handling,
+# see https://github.com/ahoward/open4/pull/30
+module Open4
+  def self.do_popen(b = nil, exception_propagation_at = nil, closefds=false, &cmd)
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+
+      cid = fork {
+        if closefds
+          exlist = [0, 1, 2] | [pw,pr,pe,ps].map{|p| [p.first.fileno, p.last.fileno] }.flatten
+          ObjectSpace.each_object(IO){|io|
+            io.close if (not io.closed?) and (not exlist.include? io.fileno) rescue nil
+          }
+        end
+
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        begin
+          cmd.call(ps)
+        rescue Exception => e
+          begin
+            Marshal.dump(e, ps.last)
+            ps.last.flush
+          rescue Errno::EPIPE
+            raise e
+          end
+        ensure
+          ps.last.close unless ps.last.closed?
+        end
+
+        exit!
+      }
+    ensure
+      $VERBOSE = verbose
+    end
+
+    [ pw.first, pr.last, pe.last, ps.last ].each { |fd| fd.close }
+
+    Open4.propagate_exception cid, ps.first if exception_propagation_at == :init
+
+    pw.last.sync = true
+
+    pi = [ pw.last, pr.first, pe.first ]
+
+    begin
+      return [cid, *pi] unless b
+
+      begin
+        b.call(cid, *pi)
+      ensure
+        pi.each { |fd| fd.close unless fd.closed? }
+      end
+
+      Open4.propagate_exception cid, ps.first if exception_propagation_at == :block
+
+      Process.waitpid2(cid).last
+    ensure
+      ps.first.close unless ps.first.closed?
+    end
+  end
+end

data/lib/switchman/r_spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "switchman/test_helper"
 
 module Switchman
@@ -36,6 +38,7 @@ module Switchman
 
         puts "Setting up sharding for all specs..."
         Shard.delete_all
+        Switchman.cache.delete("default_shard")
 
         @@shard1, @@shard2 = TestHelper.recreate_persistent_test_shards
         @@default_shard = Shard.default
@@ -64,14 +67,15 @@ module Switchman
             (@@shard3.drop_database if @@shard3) rescue nil
             @@shard1 = @@shard2 = @@shard3 = nil
             Shard.delete_all
-            Shard.default(true)
+            Shard.default(reload: true)
             next
           end
         end
         # we'll re-persist in the group's `before :all`; we don't want them to exist
         # in the db before then
         Shard.delete_all
-        Shard.default(true)
+        Switchman.cache.delete("default_shard")
+        Shard.default(reload: true)
         puts "Done!"
 
         at_exit do
@@ -99,7 +103,8 @@ module Switchman
         dup = @@default_shard.dup
         dup.id = @@default_shard.id
         dup.save!
-        Shard.default(true)
+        Switchman.cache.delete("default_shard")
+        Shard.default(reload: true)
         dup = @@shard1.dup
         dup.id = @@shard1.id
         dup.save!
@@ -118,8 +123,8 @@ module Switchman
       klass.before do
         raise "Sharding did not set up correctly" if @@sharding_failed
         Shard.clear_cache
-        if use_transactional_fixtures
-          Shard.default(true)
+        if use_transactional_tests
+          Shard.default(reload: true)
           @shard1 = Shard.find(@shard1.id)
           @shard2 = Shard.find(@shard2.id)
           shards = [@shard2]
@@ -134,7 +139,7 @@ module Switchman
 
       klass.after do
         next if @@sharding_failed
-        if use_transactional_fixtures
+        if use_transactional_tests
           shards = [@shard2]
           shards << @shard1 unless @shard1.database_server == Shard.default.database_server
           shards.each do |shard|
@@ -146,8 +151,9 @@ module Switchman
       end
 
       klass.after(:all) do
-        Shard.delete_all
-        Shard.default(true)
+        Shard.connection.update("TRUNCATE #{Shard.quoted_table_name} CASCADE")
+        Switchman.cache.delete("default_shard")
+        Shard.default(reload: true)
       end
     end
   end

data/lib/switchman/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman::Rails
   module ClassMethods
     def self.prepended(klass)