acts-as-taggable-on 7.0.0 → 9.0.1

data/lib/acts_as_taggable_on/taggable/tagged_with_query/any_tags_query.rb

@@ -1,70 +1,74 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class AnyTagsQuery < QueryBase
-    def build
-      taggable_model.select(all_fields)
-                    .where(model_has_at_least_one_tag)
-                    .order(Arel.sql(order_conditions))
-                    .readonly(false)
-    end
+# frozen_string_literal: true
 
-    private
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class AnyTagsQuery < QueryBase
+        def build
+          taggable_model.select(all_fields)
+                        .where(model_has_at_least_one_tag)
+                        .order(Arel.sql(order_conditions))
+                        .readonly(false)
+        end
 
-    def all_fields
-      taggable_arel_table[Arel.star]
-    end
+        private
 
-    def model_has_at_least_one_tag
-      tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
-    end
+        def all_fields
+          taggable_arel_table[Arel.star]
+        end
 
-    def at_least_one_tag
-      exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-                          .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-                          .and(
-                            tagging_arel_table[:tag_id].in(
-                              tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
-                            )
-                          )
+        def model_has_at_least_one_tag
+          tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
+        end
 
-      if options[:start_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
+        def at_least_one_tag
+          exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                             .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                                                             .and(
+                                                               tagging_arel_table[:tag_id].in(
+                                                                 tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+                                                               )
+                                                             )
 
-      if options[:end_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
-      end
+          if options[:start_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
 
-      if options[:on].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
+          if options[:end_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
 
-      if (owner = options[:owned_by]).present?
-        exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
-                                   .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
-      end
+          if options[:on].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
+          end
 
-      exists_contition
-    end
+          if (owner = options[:owned_by]).present?
+            exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+                                               .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+          end
 
-    def order_conditions
-      order_by = []
-      if options[:order_by_matching_tag_count].present?
-        order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
-      end
+          exists_contition
+        end
 
-      order_by << options[:order] if options[:order].present?
-      order_by.join(', ')
-    end
+        def order_conditions
+          order_by = []
+          if options[:order_by_matching_tag_count].present?
+            order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+          end
 
-    def alias_name(tag_list)
-      alias_base_name = taggable_model.base_class.name.downcase
-      taggings_context = options[:on] ? "_#{options[:on]}" : ''
+          order_by << options[:order] if options[:order].present?
+          order_by.join(', ')
+        end
 
-      taggings_alias = adjust_taggings_alias(
-          "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
-       )
+        def alias_name(tag_list)
+          alias_base_name = taggable_model.base_class.name.downcase
+          taggings_context = options[:on] ? "_#{options[:on]}" : ''
 
-      taggings_alias
+          adjust_taggings_alias(
+            "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
+          )
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/exclude_tags_query.rb

@@ -1,82 +1,85 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class ExcludeTagsQuery < QueryBase
-    def build
-      taggable_model.joins(owning_to_tagger)
-                    .where(tags_not_in_list)
-                    .having(tags_that_matches_count)
-                    .readonly(false)
-    end
-
-    private
-
-    def tags_not_in_list
-      return taggable_arel_table[:id].not_in(
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class ExcludeTagsQuery < QueryBase
+        def build
+          taggable_model.joins(owning_to_tagger)
+                        .where(tags_not_in_list)
+                        .having(tags_that_matches_count)
+                        .readonly(false)
+        end
+
+        private
+
+        def tags_not_in_list
+          taggable_arel_table[:id].not_in(
             tagging_arel_table
               .project(tagging_arel_table[:taggable_id])
               .join(tag_arel_table)
               .on(
-                  tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
-                  .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-                  .and(tags_match_type)
-                )
+                tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+                .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                .and(tags_match_type)
+              )
           )
 
-        # FIXME: missing time scope, this is also missing in the original implementation
-    end
+          # FIXME: missing time scope, this is also missing in the original implementation
+        end
 
+        def owning_to_tagger
+          return [] if options[:owned_by].blank?
 
-    def owning_to_tagger
-      return [] unless options[:owned_by].present?
+          owner = options[:owned_by]
 
-      owner = options[:owned_by]
+          arel_join = taggable_arel_table
+                      .join(tagging_arel_table)
+                      .on(
+                        tagging_arel_table[:tagger_id].eq(owner.id)
+                        .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+                        .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
+                        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                      )
 
-      arel_join = taggable_arel_table
-        .join(tagging_arel_table)
-        .on(
-            tagging_arel_table[:tagger_id].eq(owner.id)
-            .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
-            .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
-            .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-          )
+          if options[:match_all].present?
+            arel_join = arel_join
+                        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+                        .on(
+                          match_all_on_conditions
+                        )
+          end
 
-      if options[:match_all].present?
-        arel_join = arel_join
-          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
-          .on(
-            match_all_on_conditions
-          )
-      end
+          arel_join.join_sources
+        end
 
-      return arel_join.join_sources
-    end
+        def match_all_on_conditions
+          on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
 
-    def match_all_on_conditions
-      on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
 
-      if options[:start_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
 
-      if options[:end_at].present?
-        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
-      end
+          on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on])) if options[:on].present?
 
-      if options[:on].present?
-        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
+          on_condition
+        end
 
-      on_condition
-    end
+        def tags_that_matches_count
+          return [] if options[:match_all].blank?
 
-    def tags_that_matches_count
-      return [] unless options[:match_all].present?
+          taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
 
-      taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
-
-      tagging_arel_table[:taggable_id].count.eq(
-        tag_arel_table.project(Arel.star.count).where(tags_match_type)
-      )
+          tagging_arel_table[:taggable_id].count.eq(
+            tag_arel_table.project(Arel.star.count).where(tags_match_type)
+          )
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/query_base.rb

@@ -1,61 +1,69 @@
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  class QueryBase
-    def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
-      @taggable_model = taggable_model
-      @tag_model      = tag_model
-      @tagging_model  = tagging_model
-      @tag_list       = tag_list
-      @options        = options
-    end
+# frozen_string_literal: true
 
-    private
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class QueryBase
+        def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+          @taggable_model = taggable_model
+          @tag_model      = tag_model
+          @tagging_model  = tagging_model
+          @tag_list       = tag_list
+          @options        = options
+        end
 
-    attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+        private
 
-    def taggable_arel_table
-      @taggable_arel_table ||= taggable_model.arel_table
-    end
+        attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
 
-    def tag_arel_table
-      @tag_arel_table ||= tag_model.arel_table
-    end
+        def taggable_arel_table
+          @taggable_arel_table ||= taggable_model.arel_table
+        end
 
-    def tagging_arel_table
-      @tagging_arel_table ||=tagging_model.arel_table
-    end
+        def tag_arel_table
+          @tag_arel_table ||= tag_model.arel_table
+        end
 
-    def tag_match_type(tag)
-      matches_attribute = tag_arel_table[:name]
-      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+        def tagging_arel_table
+          @tagging_arel_table ||= tagging_model.arel_table
+        end
 
-      if options[:wild].present?
-        matches_attribute.matches("%#{escaped_tag(tag)}%", "!", ActsAsTaggableOn.strict_case_match)
-      else
-        matches_attribute.matches(escaped_tag(tag), "!", ActsAsTaggableOn.strict_case_match)
-      end
-    end
+        def tag_match_type(tag)
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
 
-    def tags_match_type
-      matches_attribute = tag_arel_table[:name]
-      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+          if options[:wild].present?
+            matches_attribute.matches("%#{escaped_tag(tag)}%", '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches(escaped_tag(tag), '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
 
-      if options[:wild].present?
-        matches_attribute.matches_any(tag_list.map{|tag| "%#{escaped_tag(tag)}%"}, "!", ActsAsTaggableOn.strict_case_match)
-      else
-        matches_attribute.matches_any(tag_list.map{|tag| "#{escaped_tag(tag)}"}, "!", ActsAsTaggableOn.strict_case_match)
-      end
-    end
+        def tags_match_type
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
 
-    def escaped_tag(tag)
-      tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
-      ActsAsTaggableOn::Utils.escape_like(tag)
-    end
+          if options[:wild].present?
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            "%#{escaped_tag(tag)}%"
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            escaped_tag(tag).to_s
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
+
+        def escaped_tag(tag)
+          tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+          ActsAsTaggableOn::Utils.escape_like(tag)
+        end
 
-    def adjust_taggings_alias(taggings_alias)
-      if taggings_alias.size > 75
-        taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
+        def adjust_taggings_alias(taggings_alias)
+          taggings_alias = "taggings_alias_#{Digest::SHA1.hexdigest(taggings_alias)}" if taggings_alias.size > 75
+          taggings_alias
+        end
       end
-      taggings_alias
     end
   end
 end

data/lib/acts_as_taggable_on/taggable/tagged_with_query.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 require_relative 'tagged_with_query/query_base'
 require_relative 'tagged_with_query/exclude_tags_query'
 require_relative 'tagged_with_query/any_tags_query'
 require_relative 'tagged_with_query/all_tags_query'
 
-module ActsAsTaggableOn::Taggable::TaggedWithQuery
-  def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
-    if options[:exclude].present?
-      ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
-    elsif options[:any].present?
-      AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
-    else
-      AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
+        if options[:exclude].present?
+          ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        elsif options[:any].present?
+          AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        else
+          AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on/taggable.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module Taggable
-
     def taggable?
       false
     end
@@ -54,19 +55,35 @@ module ActsAsTaggableOn
       taggable_on(true, tag_types)
     end
 
+    def acts_as_taggable_tenant(tenant)
+      if taggable?
+      else
+        class_attribute :tenant_column
+      end
+      self.tenant_column = tenant
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+    end
+
     private
 
-      # Make a model taggable on specified contexts
-      # and optionally preserves the order in which tags are created
-      #
-      # Separate methods used above for backwards compatibility
-      # so that the original acts_as_taggable_on method is unaffected
-      # as it's not possible to add another argument to the method
-      # without the tag_types being enclosed in square brackets
-      #
-      # NB: method overridden in core module in order to create tag type
-      #     associations and methods after this logic has executed
-      #
+    # Make a model taggable on specified contexts
+    # and optionally preserves the order in which tags are created
+    #
+    # Separate methods used above for backwards compatibility
+    # so that the original acts_as_taggable_on method is unaffected
+    # as it's not possible to add another argument to the method
+    # without the tag_types being enclosed in square brackets
+    #
+    # NB: method overridden in core module in order to create tag type
+    #     associations and methods after this logic has executed
+    #
     def taggable_on(preserve_tag_order, *tag_types)
       tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
 
@@ -78,6 +95,7 @@ module ActsAsTaggableOn
         self.tag_types = tag_types
         class_attribute :preserve_tag_order
         self.preserve_tag_order = preserve_tag_order
+        class_attribute :tenant_column
 
         class_eval do
           has_many :taggings, as: :taggable, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'

data/lib/acts_as_taggable_on/tagger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module Tagger
     def self.included(base)
@@ -13,7 +15,7 @@ module ActsAsTaggableOn
       #   class User < ActiveRecord::Base
       #     acts_as_tagger
       #   end
-      def acts_as_tagger(opts={})
+      def acts_as_tagger(opts = {})
         class_eval do
           owned_taggings_scope = opts.delete(:scope)
 
@@ -54,14 +56,16 @@ module ActsAsTaggableOn
       #
       # Example:
       #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
-      def tag(taggable, opts={})
+      def tag(taggable, opts = {})
         opts.reverse_merge!(force: true)
         skip_save = opts.delete(:skip_save)
         return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
 
-        fail 'You need to specify a tag context using :on' unless opts.key?(:on)
-        fail 'You need to specify some tags using :with' unless opts.key?(:with)
-        fail "No context :#{opts[:on]} defined in #{taggable.class}" unless opts[:force] || taggable.tag_types.include?(opts[:on])
+        raise 'You need to specify a tag context using :on' unless opts.key?(:on)
+        raise 'You need to specify some tags using :with' unless opts.key?(:with)
+        unless opts[:force] || taggable.tag_types.include?(opts[:on])
+          raise "No context :#{opts[:on]} defined in #{taggable.class}"
+        end
 
         taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
         taggable.save unless skip_save

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
-  class Tagging < ::ActiveRecord::Base #:nodoc:
+  class Tagging < ::ActiveRecord::Base # :nodoc:
     self.table_name = ActsAsTaggableOn.taggings_table
 
     DEFAULT_CONTEXT = 'tags'
@@ -14,10 +16,12 @@ module ActsAsTaggableOn
     scope :by_contexts, ->(contexts) { where(context: (contexts || DEFAULT_CONTEXT)) }
     scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
 
+    scope :by_tenant, ->(tenant) { where(tenant: tenant) }
+
     validates_presence_of :context
     validates_presence_of :tag_id
 
-    validates_uniqueness_of :tag_id, scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]
+    validates_uniqueness_of :tag_id, scope: %i[taggable_type taggable_id context tagger_id tagger_type]
 
     after_destroy :remove_unused_tags
 
@@ -27,8 +31,8 @@ module ActsAsTaggableOn
       if ActsAsTaggableOn.remove_unused_tags
         if ActsAsTaggableOn.tags_counter
           tag.destroy if tag.reload.taggings_count.zero?
-        else
-          tag.destroy if tag.reload.taggings.count.zero?
+        elsif tag.reload.taggings.none?
+          tag.destroy
         end
       end
     end

data/lib/acts_as_taggable_on/tags_helper.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   module TagsHelper
     # See the wiki for an example using tag_cloud.
     def tag_cloud(tags, classes)
       return [] if tags.empty?
 
-      max_count = tags.sort_by(&:taggings_count).last.taggings_count.to_f
+      max_count = tags.max_by(&:taggings_count).taggings_count.to_f
 
       tags.each do |tag|
         index = ((tag.taggings_count / max_count) * (classes.size - 1))

data/lib/acts_as_taggable_on/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This module is deprecated and will be removed in the incoming versions
 
 module ActsAsTaggableOn
@@ -9,7 +11,7 @@ module ActsAsTaggableOn
       end
 
       def using_postgresql?
-        connection && connection.adapter_name == 'PostgreSQL'
+        connection && %w[PostgreSQL PostGIS].include?(connection.adapter_name)
       end
 
       def using_mysql?
@@ -30,7 +32,7 @@ module ActsAsTaggableOn
 
       # escape _ and % characters in strings, since these are wildcards in SQL.
       def escape_like(str)
-        str.gsub(/[!%_]/) { |x| '!' + x }
+        str.gsub(/[!%_]/) { |x| "!#{x}" }
       end
     end
   end

data/lib/acts_as_taggable_on/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
-  VERSION = '7.0.0'
+  VERSION = '9.0.1'
 end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -14,7 +14,7 @@ end
 describe ActsAsTaggableOn::Tag do
   before(:each) do
     @tag = ActsAsTaggableOn::Tag.new
-    @user = TaggableModel.create(name: 'Pablo')
+    @user = TaggableModel.create(name: 'Pablo', tenant_id: 100)
   end
 
 
@@ -70,6 +70,21 @@ describe ActsAsTaggableOn::Tag do
     end
   end
 
+  describe 'for tenant' do
+    before(:each) do
+      @user.skill_list.add('ruby')
+      @user.save
+    end
+
+    it 'should return tags for the tenant' do
+      expect(ActsAsTaggableOn::Tag.for_tenant('100').pluck(:name)).to include('ruby')
+    end
+
+    it 'should not return tags for other tenants' do
+      expect(ActsAsTaggableOn::Tag.for_tenant('200').pluck(:name)).to_not include('ruby')
+    end
+  end
+
   describe 'find or create by name' do
     before(:each) do
       @tag.name = 'awesome'

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -109,6 +109,10 @@ describe 'Taggable' do
     expect(@taggable.tag_types).to eq(TaggableModel.tag_types)
   end
 
+  it 'should have tenant column' do
+    expect(TaggableModel.tenant_column).to eq(:tenant_id)
+  end
+
   it 'should have tag_counts_on' do
     expect(TaggableModel.tag_counts_on(:tags)).to be_empty
 
@@ -676,11 +680,11 @@ describe 'Taggable' do
     end
 
     it 'should return all column names joined for TaggableModel GROUP clause' do
-      expect(@taggable.grouped_column_names_for(TaggableModel)).to eq('taggable_models.id, taggable_models.name, taggable_models.type')
+      expect(@taggable.grouped_column_names_for(TaggableModel)).to eq('taggable_models.id, taggable_models.name, taggable_models.type, taggable_models.tenant_id')
     end
 
     it 'should return all column names joined for NonStandardIdTaggableModel GROUP clause' do
-      expect(@taggable.grouped_column_names_for(TaggableModel)).to eq("taggable_models.#{TaggableModel.primary_key}, taggable_models.name, taggable_models.type")
+      expect(@taggable.grouped_column_names_for(TaggableModel)).to eq("taggable_models.#{TaggableModel.primary_key}, taggable_models.name, taggable_models.type, taggable_models.tenant_id")
     end
   end