activerecord-multi-tenant 1.2.0 → 2.4.0

data/lib/activerecord-multi-tenant/query_rewriter.rb

@@ -1,6 +1,7 @@
 require 'active_record'
-require_relative "./arel_visitors_depth_first.rb" unless Arel::Visitors.const_defined?(:DepthFirst)
+require_relative './arel_visitors_depth_first' unless Arel::Visitors.const_defined?(:DepthFirst)
 
+# Iterates AST and adds tenant enforcement clauses to all relations
 module MultiTenant
   class Table
     attr_reader :arel_table
@@ -9,9 +10,9 @@ module MultiTenant
       @arel_table = arel_table
     end
 
-    def eql?(rhs)
-      self.class == rhs.class &&
-        equality_fields.eql?(rhs.equality_fields)
+    def eql?(other)
+      self.class == other.class &&
+        equality_fields.eql?(other.equality_fields)
     end
 
     def hash
@@ -44,6 +45,7 @@ module MultiTenant
 
     def visited_relation(relation)
       return unless @discovering
+
       @known_relations << Table.new(relation)
     end
 
@@ -56,9 +58,13 @@ module MultiTenant
     end
   end
 
-  class ArelTenantVisitor < Arel::Visitors.const_defined?(:DepthFirst) ? Arel::Visitors::DepthFirst : ::MultiTenant::ArelVisitorsDepthFirst
+  class ArelTenantVisitor < if Arel::Visitors.const_defined?(:DepthFirst)
+                              Arel::Visitors::DepthFirst
+                            else
+                              ::MultiTenant::ArelVisitorsDepthFirst
+                            end
     def initialize(arel)
-      super(Proc.new {})
+      super(proc {})
       @statement_node_id = nil
 
       @contexts = []
@@ -68,61 +74,72 @@ module MultiTenant
 
     attr_reader :contexts
 
+    # rubocop:disable Naming/MethodName
     def visit_Arel_Attributes_Attribute(*args)
       return if @current_context.nil?
+
       super(*args)
     end
 
-    def visit_Arel_Nodes_Equality(o, *args)
-      if o.left.is_a?(Arel::Attributes::Attribute)
-        table_name = o.left.relation.table_name
+    def visit_Arel_Nodes_Equality(obj, *args)
+      if obj.left.is_a?(Arel::Attributes::Attribute)
+        table_name = MultiTenant::TableNode.table_name(obj.left.relation)
         model = MultiTenant.multi_tenant_model_for_table(table_name)
-        @current_context.visited_handled_relation(o.left.relation) if model.present? && o.left.name.to_s == model.partition_key.to_s
+        if model.present? && obj.left.name.to_s == model.partition_key.to_s
+          @current_context.visited_handled_relation(obj.left.relation)
+        end
       end
-      super(o, *args)
+      super(obj, *args)
     end
 
-    def visit_MultiTenant_TenantEnforcementClause(o, *)
-      @current_context.visited_handled_relation(o.tenant_attribute.relation)
+    def visit_MultiTenant_TenantEnforcementClause(obj, *)
+      @current_context.visited_handled_relation(obj.tenant_attribute.relation)
     end
 
-    def visit_MultiTenant_TenantJoinEnforcementClause(o, *)
-      @current_context.visited_handled_relation(o.tenant_attribute.relation)
+    def visit_MultiTenant_TenantJoinEnforcementClause(obj, *)
+      @current_context.visited_handled_relation(obj.tenant_attribute.relation)
     end
 
-    def visit_Arel_Table(o, _collector = nil)
-      @current_context.visited_relation(o) if tenant_relation?(o.table_name)
+    def visit_Arel_Table(obj, _collector = nil)
+      @current_context.visited_relation(obj) if tenant_relation?(MultiTenant::TableNode.table_name(obj))
     end
-    alias :visit_Arel_Nodes_TableAlias :visit_Arel_Table
 
-    def visit_Arel_Nodes_SelectCore(o, *args)
-      nest_context(o) do
+    alias visit_Arel_Nodes_TableAlias visit_Arel_Table
+
+    def visit_Arel_Nodes_SelectCore(obj, *_args)
+      nest_context(obj) do
         @current_context.discover_relations do
-          visit o.source
+          visit obj.source
         end
-        visit o.wheres
-        visit o.groups
-        visit o.windows
-        if defined?(o.having)
-          visit o.having
+        visit obj.wheres
+        visit obj.groups
+        visit obj.windows
+        if defined?(obj.having)
+          visit obj.having
         else
-          visit o.havings
+          visit obj.havings
         end
       end
     end
 
-    def visit_Arel_Nodes_OuterJoin(o, collector = nil)
-      nest_context(o) do
+    # rubocop:enable Naming/MethodName
+
+    # rubocop:disable Naming/MethodName
+    def visit_Arel_Nodes_OuterJoin(obj, _collector = nil)
+      nest_context(obj) do
         @current_context.discover_relations do
-          visit o.left
-          visit o.right
+          visit obj.left
+          visit obj.right
         end
       end
     end
-    alias :visit_Arel_Nodes_FullOuterJoin :visit_Arel_Nodes_OuterJoin
-    alias :visit_Arel_Nodes_RightOuterJoin :visit_Arel_Nodes_OuterJoin
 
-    alias :visit_ActiveModel_Attribute :terminal
+    # rubocop:enable Naming/MethodName
+
+    alias visit_Arel_Nodes_FullOuterJoin visit_Arel_Nodes_OuterJoin
+    alias visit_Arel_Nodes_RightOuterJoin visit_Arel_Nodes_OuterJoin
+
+    alias visit_ActiveModel_Attribute terminal
 
     private
 
@@ -138,13 +155,16 @@ module MultiTenant
       DISPATCH
     end
 
+    # rubocop:disable Naming/AccessorMethodName
     def get_dispatch_cache
       dispatch
     end
 
-    def nest_context(o)
+    # rubocop:enable Naming/AccessorMethodName
+
+    def nest_context(obj)
       old_context = @current_context
-      @current_context = Context.new(o)
+      @current_context = Context.new(obj)
       @contexts << @current_context
 
       yield
@@ -155,25 +175,33 @@ module MultiTenant
 
   class BaseTenantEnforcementClause < Arel::Nodes::Node
     attr_reader :tenant_attribute
+
     def initialize(tenant_attribute)
+      super()
       @tenant_attribute = tenant_attribute
-      @tenant_model = MultiTenant.multi_tenant_model_for_table(tenant_attribute.relation.table_name)
+      @tenant_model = MultiTenant.multi_tenant_model_for_table(
+        MultiTenant::TableNode.table_name(tenant_attribute.relation)
+      )
+    end
+
+    def to_s
+      to_sql
     end
 
-    def to_s; to_sql; end
-    def to_str; to_sql; end
+    def to_str
+      to_sql
+    end
 
     def to_sql(*)
       collector = Arel::Collectors::SQLString.new
       collector = @tenant_model.connection.visitor.accept tenant_arel, collector
       collector.value
     end
-
-
   end
 
   class TenantEnforcementClause < BaseTenantEnforcementClause
     private
+
     def tenant_arel
       if defined?(Arel::Nodes::Quoted)
         @tenant_attribute.eq(Arel::Nodes::Quoted.new(MultiTenant.current_tenant_id))
@@ -183,36 +211,39 @@ module MultiTenant
     end
   end
 
-
   class TenantJoinEnforcementClause < BaseTenantEnforcementClause
     attr_reader :table_left
+
     def initialize(tenant_attribute, table_left)
       super(tenant_attribute)
       @table_left = table_left
-      @model_left = MultiTenant.multi_tenant_model_for_table(table_left.table_name)
+      @model_left = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(table_left))
     end
 
     private
+
     def tenant_arel
       @tenant_attribute.eq(@table_left[@model_left.partition_key])
     end
   end
 
-
   module TenantValueVisitor
-    def visit_MultiTenant_TenantEnforcementClause(o, collector)
-      collector << o
+    # rubocop:disable Naming/MethodName
+    def visit_MultiTenant_TenantEnforcementClause(obj, collector)
+      collector << obj
     end
 
-    def visit_MultiTenant_TenantJoinEnforcementClause(o, collector)
-      collector << o
+    def visit_MultiTenant_TenantJoinEnforcementClause(obj, collector)
+      collector << obj
     end
+
+    # rubocop:enable Naming/MethodName
   end
 
   module DatabaseStatements
     def join_to_update(update, *args)
       update = super(update, *args)
-      model = MultiTenant.multi_tenant_model_for_table(update.ast.relation.table_name)
+      model = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(update.ast.relation))
       if model.present? && !MultiTenant.with_write_only_mode_enabled? && MultiTenant.current_tenant_id.present?
         update.where(MultiTenant::TenantEnforcementClause.new(model.arel_table[model.partition_key]))
       end
@@ -221,7 +252,7 @@ module MultiTenant
 
     def join_to_delete(delete, *args)
       delete = super(delete, *args)
-      model = MultiTenant.multi_tenant_model_for_table(delete.ast.left.table_name)
+      model = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(delete.ast.left))
       if model.present? && !MultiTenant.with_write_only_mode_enabled? && MultiTenant.current_tenant_id.present?
         delete.where(MultiTenant::TenantEnforcementClause.new(model.arel_table[model.partition_key]))
       end
@@ -254,64 +285,61 @@ Arel::Visitors::ToSql.include(MultiTenant::TenantValueVisitor)
 require 'active_record/relation'
 module ActiveRecord
   module QueryMethods
-    alias :build_arel_orig :build_arel
+    alias build_arel_orig build_arel
+
     def build_arel(*args)
       arel = build_arel_orig(*args)
 
-      if !MultiTenant.with_write_only_mode_enabled?
+      unless MultiTenant.with_write_only_mode_enabled?
         visitor = MultiTenant::ArelTenantVisitor.new(arel)
 
         visitor.contexts.each do |context|
           node = context.arel_node
 
           context.unhandled_relations.each do |relation|
-            model = MultiTenant.multi_tenant_model_for_table(relation.arel_table.table_name)
+            model = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(relation.arel_table))
 
             if MultiTenant.current_tenant_id
               enforcement_clause = MultiTenant::TenantEnforcementClause.new(relation.arel_table[model.partition_key])
               case node
-              when Arel::Nodes::Join #Arel::Nodes::OuterJoin, Arel::Nodes::RightOuterJoin, Arel::Nodes::FullOuterJoin
+              when Arel::Nodes::Join # Arel::Nodes::OuterJoin, Arel::Nodes::RightOuterJoin, Arel::Nodes::FullOuterJoin
                 node.right.expr = node.right.expr.and(enforcement_clause)
               when Arel::Nodes::SelectCore
                 if node.wheres.empty?
                   node.wheres = [enforcement_clause]
+                elsif node.wheres[0].is_a?(Arel::Nodes::And)
+                  node.wheres[0].children << enforcement_clause
                 else
-                  if node.wheres[0].is_a?(Arel::Nodes::And)
-                    node.wheres[0].children << enforcement_clause
-                  else
-                    node.wheres[0] = enforcement_clause.and(node.wheres[0])
-                  end
+                  node.wheres[0] = enforcement_clause.and(node.wheres[0])
                 end
               else
-                raise "UnknownContext"
+                raise 'UnknownContext'
               end
             end
 
-            if node.is_a?(Arel::Nodes::SelectCore) || node.is_a?(Arel::Nodes::Join)
-              if node.is_a?Arel::Nodes::Join
-                node_list = [node]
-              else
-                node_list = node.source.right
-              end
+            next unless node.is_a?(Arel::Nodes::SelectCore) || node.is_a?(Arel::Nodes::Join)
 
-              node_list.select{ |n| n.is_a? Arel::Nodes::Join }.each do |node_join|
-                if (!node_join.right ||
-                    (ActiveRecord::VERSION::MAJOR == 5 &&
-                     !node_join.right.expr.right.is_a?(Arel::Attributes::Attribute)))
-                  next
-                end
+            node_list = if node.is_a? Arel::Nodes::Join
+                          [node]
+                        else
+                          node.source.right
+                        end
 
-                relation_right, relation_left = relations_from_node_join(node_join)
+            node_list.select { |n| n.is_a? Arel::Nodes::Join }.each do |node_join|
+              next unless node_join.right
 
-                next unless relation_right && relation_left
+              relation_right, relation_left = relations_from_node_join(node_join)
 
-                model_right = MultiTenant.multi_tenant_model_for_table(relation_left.table_name)
-                model_left = MultiTenant.multi_tenant_model_for_table(relation_right.table_name)
-                if model_right && model_left
-                  join_enforcement_clause = MultiTenant::TenantJoinEnforcementClause.new(relation_left[model_left.partition_key], relation_right)
-                  node_join.right.expr = node_join.right.expr.and(join_enforcement_clause)
-                end
-              end
+              next unless relation_right && relation_left
+
+              model_right = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(relation_left))
+              model_left = MultiTenant.multi_tenant_model_for_table(MultiTenant::TableNode.table_name(relation_right))
+              next unless model_right && model_left
+
+              join_enforcement_clause = MultiTenant::TenantJoinEnforcementClause.new(
+                relation_right[model_right.partition_key], relation_left
+              )
+              node_join.right.expr = node_join.right.expr.and(join_enforcement_clause)
             end
           end
         end
@@ -321,28 +349,29 @@ module ActiveRecord
     end
 
     private
+
     def relations_from_node_join(node_join)
-      if ActiveRecord::VERSION::MAJOR == 5 || node_join.right.expr.is_a?(Arel::Nodes::Equality)
+      if node_join.right.expr.is_a?(Arel::Nodes::Equality)
         return node_join.right.expr.right.relation, node_join.right.expr.left.relation
       end
 
-      children = node_join.right.expr.children
+      children = [node_join.right.expr.children].flatten
 
-      tenant_applied = children.any?(MultiTenant::TenantEnforcementClause) || children.any?(MultiTenant::TenantJoinEnforcementClause)
-      if tenant_applied || children.empty?
-        return nil, nil
+      tenant_applied = children.any? do |c|
+        c.is_a?(MultiTenant::TenantEnforcementClause) || c.is_a?(MultiTenant::TenantJoinEnforcementClause)
       end
+      return nil, nil if tenant_applied || children.empty?
 
-      if children[0].right.respond_to?('relation') && children[0].left.respond_to?('relation')
-        return children[0].right.relation, children[0].left.relation
+      child = children.first.respond_to?(:children) ? children.first.children.first : children.first
+      if child.right.respond_to?(:relation) && child.left.respond_to?(:relation)
+        return child.right.relation, child.left.relation
       end
 
-      return nil, nil
+      [nil, nil]
     end
   end
 end
 
-require 'active_record/base'
 module MultiTenantFindBy
   def cached_find_by_statement(key, &block)
     return super unless respond_to?(:scoped_by_tenant?) && scoped_by_tenant?
@@ -352,4 +381,6 @@ module MultiTenantFindBy
   end
 end
 
-ActiveRecord::Base.singleton_class.prepend(MultiTenantFindBy)
+ActiveSupport.on_load(:active_record) do |base|
+  base.singleton_class.prepend(MultiTenantFindBy)
+end

data/lib/activerecord-multi-tenant/sidekiq.rb

@@ -1,14 +1,17 @@
 require 'sidekiq/client'
 
+# Adds methods to handle tenant information both in the client and server.
 module Sidekiq::Middleware::MultiTenant
   # Get the current tenant and store in the message to be sent to Sidekiq.
   class Client
-    def call(worker_class, msg, queue, redis_pool)
-      msg['multi_tenant'] ||=
-        {
-          'class' => MultiTenant.current_tenant_class,
-          'id' => MultiTenant.current_tenant_id
-        } if MultiTenant.current_tenant.present?
+    def call(_worker_class, msg, _queue, _redis_pool)
+      if MultiTenant.current_tenant.present?
+        msg['multi_tenant'] ||=
+          {
+            'class' => MultiTenant.current_tenant_class,
+            'id' => MultiTenant.current_tenant_id
+          }
+      end
 
       yield
     end
@@ -16,16 +19,14 @@ module Sidekiq::Middleware::MultiTenant
 
   # Pull the tenant out and run the current thread with it.
   class Server
-    def call(worker_class, msg, queue)
-      if msg.has_key?('multi_tenant')
+    def call(_worker_class, msg, _queue, &block)
+      if msg.key?('multi_tenant')
         tenant = begin
-                   msg['multi_tenant']['class'].constantize.find(msg['multi_tenant']['id'])
-                 rescue ActiveRecord::RecordNotFound
-                   msg['multi_tenant']['id']
-                 end
-        MultiTenant.with(tenant) do
-          yield
+          msg['multi_tenant']['class'].constantize.find(msg['multi_tenant']['id'])
+        rescue ActiveRecord::RecordNotFound
+          msg['multi_tenant']['id']
         end
+        MultiTenant.with(tenant, &block)
       else
         yield
       end
@@ -33,26 +34,52 @@ module Sidekiq::Middleware::MultiTenant
   end
 end
 
+# Configure Sidekiq to use the multi-tenant client and server middleware to add (client/server)/process(server)
+# tenant information.
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Middleware::MultiTenant::Server
+  end
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Middleware::MultiTenant::Client
+  end
+end
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Middleware::MultiTenant::Client
+  end
+end
+
+# Bulk push support for Sidekiq while setting multi-tenant information.
+# This is a copy of the Sidekiq::Client#push_bulk method with the addition of
+# setting the multi-tenant information for each job.
 module Sidekiq
   class Client
+    # Allows the caller to enqueue multiple Sidekiq jobs with
+    # tenant information in a single call. It ensures that each job is processed
+    # within the correct tenant context and returns an array of job IDs for the enqueued jobs
     def push_bulk_with_tenants(items)
-      job = items['jobs'].first
-      return [] unless job # no jobs to push
-      raise ArgumentError, "Bulk arguments must be an Array of Hashes: [{ 'args' => [1], 'tenant_id' => 1 }, ...]" if !job.is_a?(Hash)
+      first_job = items['jobs'].first
+      return [] unless first_job # no jobs to push
+      unless first_job.is_a?(Hash)
+        raise ArgumentError, "Bulk arguments must be an Array of Hashes: [{ 'args' => [1], 'tenant_id' => 1 }, ...]"
+      end
 
       normed = normalize_item(items.except('jobs').merge('args' => []))
       payloads = items['jobs'].map do |job|
         MultiTenant.with(job['tenant_id']) do
           copy = normed.merge('args' => job['args'], 'jid' => SecureRandom.hex(12), 'enqueued_at' => Time.now.to_f)
           result = process_single(items['class'], copy)
-          result ? result : nil
+          result || nil
         end
       end.compact
 
-      raw_push(payloads) if !payloads.empty?
+      raw_push(payloads) unless payloads.empty?
       payloads.collect { |payload| payload['jid'] }
     end
 
+    # Enabling the push_bulk_with_tenants method to be called directly on the Sidekiq::Client class
     class << self
       def push_bulk_with_tenants(items)
         new.push_bulk_with_tenants(items)

data/lib/activerecord-multi-tenant/table_node.rb

@@ -0,0 +1,13 @@
+module MultiTenant
+  module TableNode
+    # Return table name
+    def self.table_name(node)
+      # NOTE: Arel::Nodes::Table#table_name is removed in Rails 7.1
+      if node.is_a?(Arel::Nodes::TableAlias)
+        node.table_name
+      else
+        node.name
+      end
+    end
+  end
+end

data/lib/activerecord-multi-tenant/version.rb

@@ -1,3 +1,3 @@
 module MultiTenant
-  VERSION = '1.2.0'
+  VERSION = '2.4.0'.freeze
 end

data/lib/activerecord-multi-tenant.rb

@@ -1,13 +1,3 @@
-if Object.const_defined?(:ActionController)
-  require_relative 'activerecord-multi-tenant/controller_extensions'
-end
-require_relative 'activerecord-multi-tenant/copy_from_client'
-require_relative 'activerecord-multi-tenant/fast_truncate'
-require_relative 'activerecord-multi-tenant/migrations'
-require_relative 'activerecord-multi-tenant/model_extensions'
-require_relative 'activerecord-multi-tenant/multi_tenant'
-require_relative 'activerecord-multi-tenant/query_rewriter'
-require_relative 'activerecord-multi-tenant/query_monitor'
-require_relative 'activerecord-multi-tenant/version'
-require_relative 'activerecord-multi-tenant/with_lock'
-require_relative 'activerecord-multi-tenant/persistence_extension'
+# frozen_string_literal: true
+
+require 'activerecord_multi_tenant'

data/lib/activerecord_multi_tenant.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'activerecord-multi-tenant/controller_extensions' if Object.const_defined?(:ActionController)
+require_relative 'activerecord-multi-tenant/copy_from_client'
+require_relative 'activerecord-multi-tenant/fast_truncate'
+require_relative 'activerecord-multi-tenant/migrations'
+require_relative 'activerecord-multi-tenant/model_extensions'
+require_relative 'activerecord-multi-tenant/multi_tenant'
+require_relative 'activerecord-multi-tenant/query_rewriter'
+require_relative 'activerecord-multi-tenant/query_monitor'
+require_relative 'activerecord-multi-tenant/table_node'
+require_relative 'activerecord-multi-tenant/version'
+require_relative 'activerecord-multi-tenant/habtm'

data/spec/activerecord-multi-tenant/associations_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe MultiTenant, 'Association methods' do
+  let(:account1) { Account.create! name: 'test1' }
+  let(:account2) { Account.create! name: 'test2' }
+  let(:project1) { Project.create! name: 'something1', account: account1 }
+  let(:project2) { Project.create! name: 'something2', account: account2, id: project1.id }
+
+  let(:task1) { Task.create! name: 'task1', project: project1, account: account1 }
+  let(:task2) { Task.create! name: 'task2', project: project2, account: account2, id: task1.id }
+  let(:manager1) { Manager.create! name: 'manager1', account: account1, tasks: [task1] }
+  let(:project3) { Project.create! name: 'something3', account: account1, managers: [manager1] }
+
+  context 'include the tenant_id in queries and' do
+    it 'creates a task with correct account_id' do
+      expect(project2.tasks.create(name: 'task3').account_id).to eq(account2.id)
+    end
+    it 'return correct account_id' do
+      expect(task1.project.account_id).to_not eq(task2.project.account_id) # belongs_to
+      expect(project2.tasks.count).to eq(1)
+      expect(project2.tasks.first.account_id).to eq(account2.id) # has_many
+    end
+
+    it 'check has_many_belongs_to' do
+      MultiTenant.with(account1) do
+        expect(manager1.tasks.first.account_id).to eq(task1.account_id) # has_many
+      end
+    end
+
+    it 'check has_many_belongs_to without tenant in the intermediate table' do
+      MultiTenant.with(account1) do
+        expect(manager1.tasks.first.account_id).to eq(task1.account_id) # has_many
+      end
+    end
+
+    it 'check has_many_belongs_to tenant_enabled false' do
+      MultiTenant.with(account1) do
+        expect(project3.managers.first.id).to eq(manager1.id) # has_many
+      end
+    end
+  end
+end

data/spec/activerecord-multi-tenant/controller_extensions_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "Controller Extensions", type: :controller do
+describe 'Controller Extensions', type: :controller do
   class Account
     attr_accessor :name
   end
@@ -31,7 +33,6 @@ describe "Controller Extensions", type: :controller do
     end
   end
 
-
   class APIApplicationController < ActionController::API
     include Rails.application.routes.url_helpers
     set_current_tenant_through_filter

data/spec/activerecord-multi-tenant/fast_truncate_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe MultiTenant::FastTruncate do
@@ -5,19 +7,19 @@ describe MultiTenant::FastTruncate do
     MultiTenant::FastTruncate.run
   end
 
-  it "truncates tables that have exactly one row inserted" do
+  it 'truncates tables that have exactly one row inserted' do
     Account.create! name: 'foo'
-    expect {
+    expect do
       MultiTenant::FastTruncate.run
-    }.to change { Account.count }.from(1).to(0)
+    end.to change { Account.count }.from(1).to(0)
   end
 
-  it "truncates tables that have more than one row inserted" do
+  it 'truncates tables that have more than one row inserted' do
     Account.create! name: 'foo'
     Account.create! name: 'bar'
 
-    expect {
+    expect do
       MultiTenant::FastTruncate.run
-    }.to change { Account.count }.from(2).to(0)
+    end.to change { Account.count }.from(2).to(0)
   end
 end