acts-as-taggable-on 3.5.0 → 8.1.0

data/spec/acts_as_taggable_on/caching_spec.rb

@@ -31,40 +31,40 @@ describe 'Acts As Taggable On' do
     end
 
     it 'should cache tags' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       expect(@taggable.cached_tag_list).to eq('awesome, epic')
 
-      @another_taggable.update_attributes(language_list: 'ruby, .net')
+      @another_taggable.update(language_list: 'ruby, .net')
       expect(@another_taggable.cached_language_list).to eq('ruby, .net')
     end
 
     it 'should keep the cache' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
       @taggable.save!
       expect(@taggable.cached_tag_list).to eq('awesome, epic')
     end
 
     it 'should update the cache' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
-      @taggable.update_attributes(tag_list: 'awesome')
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome')
       expect(@taggable.cached_tag_list).to eq('awesome')
     end
 
     it 'should remove the cache' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
-      @taggable.update_attributes(tag_list: '')
+      @taggable.update(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: '')
       expect(@taggable.cached_tag_list).to be_blank
     end
 
     it 'should have a tag list' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
       expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
     end
 
     it 'should keep the tag list' do
-      @taggable.update_attributes(tag_list: 'awesome, epic')
+      @taggable.update(tag_list: 'awesome, epic')
       @taggable = CachedModel.find(@taggable.id)
       @taggable.save!
       expect(@taggable.tag_list.sort).to eq(%w(awesome epic).sort)
@@ -75,6 +75,52 @@ describe 'Acts As Taggable On' do
       CachedModel.reset_column_information
       expect(CachedModel.instance_variable_get(:@acts_as_taggable_on_cache_columns)).to eql(nil)
     end
+
+    it 'should not override a user-defined columns method' do
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include('ignored_column')
+      ColumnsOverrideModel.acts_as_taggable
+      expect(ColumnsOverrideModel.columns.map(&:name)).not_to include('ignored_column')
+    end
+  end
+
+  describe 'with a custom delimiter' do
+    before(:each) do
+      @taggable = CachedModel.new(name: 'Bob Jones')
+      @another_taggable = OtherCachedModel.new(name: 'John Smith')
+      ActsAsTaggableOn.delimiter = ';'
+    end
+
+    after(:all) do
+      ActsAsTaggableOn.delimiter = ','
+    end
+
+    it 'should cache tags with custom delimiter' do
+      @taggable.update(tag_list: 'awesome; epic')
+      expect(@taggable.tag_list).to eq(['awesome', 'epic'])
+      expect(@taggable.cached_tag_list).to eq('awesome; epic')
+
+      @taggable = CachedModel.find_by_name('Bob Jones')
+      expect(@taggable.tag_list).to eq(['awesome', 'epic'])
+      expect(@taggable.cached_tag_list).to eq('awesome; epic')
+    end
+  end
+
+  describe 'Cache methods initialization on new models' do
+    before(:all) do
+      ActiveRecord::Base.connection.execute(
+        'INSERT INTO cache_methods_injected_models (cached_tag_list) VALUES (\'ciao\')'
+      )
+      class CacheMethodsInjectedModel < ActiveRecord::Base
+        acts_as_taggable
+      end
+    end
+    after(:all) { Object.send(:remove_const, :CacheMethodsInjectedModel) }
+
+    it 'cached_tag_list_on? get injected correctly' do
+      expect do
+        CacheMethodsInjectedModel.first.tag_list
+      end.not_to raise_error
+    end
   end
 
   describe 'CachingWithArray' do

data/spec/acts_as_taggable_on/{taggable/dirty_spec.rb → dirty_spec.rb}

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 require 'spec_helper'
 
-describe ActsAsTaggableOn::Taggable::Dirty do
+describe 'Dirty behavior of taggable objects' do
   context 'with un-contexted tags' do
     before(:each) do
       @taggable = TaggableModel.create(tag_list: 'awesome, epic')
@@ -14,19 +14,27 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'tag_list' => ['awesome, epic', ['one']]})
+        expect(@taggable.changes).to eq({'tag_list' => [['awesome', 'epic'], ['one']]})
       end
 
-      it 'flags tag_list as changed' do
-        expect(@taggable.tag_list_changed?).to be_truthy
+      it 'should show changes of freshly initialized dirty object' do
+        taggable = TaggableModel.find(@taggable.id)
+        taggable.tag_list = 'one'
+        expect(taggable.changes).to eq({'tag_list' => [['awesome', 'epic'], ['one']]})
+      end
+
+      if Rails.version >= "5.1"
+        it 'flags tag_list as changed' do
+          expect(@taggable.will_save_change_to_tag_list?).to be_truthy
+        end
       end
 
       it 'preserves original value' do
-        expect(@taggable.tag_list_was).to eq('awesome, epic')
+        expect(@taggable.tag_list_was).to eq(['awesome', 'epic'])
       end
 
       it 'shows what the change was' do
-        expect(@taggable.tag_list_change).to eq(['awesome, epic', ['one']])
+        expect(@taggable.tag_list_change).to eq([['awesome', 'epic'], ['one']])
       end
 
       context 'without order' do
@@ -90,7 +98,7 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'should show changes of dirty object' do
-        expect(@taggable.changes).to eq({'language_list' => ['awesome, epic', ['one']]})
+        expect(@taggable.changes).to eq({'language_list' => [['awesome', 'epic'], ['one']]})
       end
 
       it 'flags language_list as changed' do
@@ -98,15 +106,11 @@ describe ActsAsTaggableOn::Taggable::Dirty do
       end
 
       it 'preserves original value' do
-        expect(@taggable.language_list_was).to eq('awesome, epic')
+        expect(@taggable.language_list_was).to eq(['awesome', 'epic'])
       end
 
       it 'shows what the change was' do
-        expect(@taggable.language_list_change).to eq(['awesome, epic', ['one']])
-      end
-
-      it 'shows what the changes were' do
-        expect(@taggable.language_list_changes).to eq(['awesome, epic', ['one']])
+        expect(@taggable.language_list_change).to eq([['awesome', 'epic'], ['one']])
       end
     end
 
@@ -123,5 +127,16 @@ describe ActsAsTaggableOn::Taggable::Dirty do
         expect(@taggable.changes).to be_empty
       end
     end
+
+    context 'when language_list changed by association' do
+      let(:tag) { ActsAsTaggableOn::Tag.new(name: 'one') }
+
+      it 'flags language_list as changed' do
+        expect(@taggable.changes).to be_empty
+        @taggable.languages << tag
+        expect(@taggable.language_list_changed?).to be_truthy
+      end
+    end
+
   end
 end

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -127,9 +127,9 @@ describe 'Single Table Inheritance' do
       altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.save!
 
-      expect(InheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tag_counts_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
+      expect(InheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
     end
 
     it 'should have different tags_on for inherited models' do
@@ -138,9 +138,9 @@ describe 'Single Table Inheritance' do
       altered_inheriting.tag_list = 'fork, spoon'
       altered_inheriting.save!
 
-      expect(InheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso))
-      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(fork spoon))
-      expect(TaggableModel.tags_on(:tags, order: 'tags.id').map(&:name)).to eq(%w(bob kelso fork spoon))
+      expect(InheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
     end
 
     it 'should store same tag without validation conflict' do
@@ -150,7 +150,12 @@ describe 'Single Table Inheritance' do
       inheriting_model.tag_list = 'one'
       inheriting_model.save!
 
-      inheriting_model.update_attributes! name: 'foo'
+      inheriting_model.update! name: 'foo'
+    end
+
+    it "should only join with taggable's table to check type for inherited models" do
+      expect(TaggableModel.tag_counts_on(:tags).to_sql).to_not match /INNER JOIN taggable_models ON/
+      expect(InheritingTaggableModel.tag_counts_on(:tags).to_sql).to match /INNER JOIN taggable_models ON/
     end
   end
 
@@ -170,11 +175,27 @@ describe 'Single Table Inheritance' do
       expect(taggable.tags_from(student)).to eq(%w(ruby scheme))
     end
 
+    it 'returns all owner tags on the taggable' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      student.tag(taggable, with: 'skill_one', on: :skills)
+      student.tag(taggable, with: 'english, spanish', on: :language)
+      expect(taggable.owner_tags(student).count).to eq(5)
+      expect(taggable.owner_tags(student).sort == %w(english ruby scheme skill_one spanish))
+    end
+
+
     it 'returns owner tags on the tagger' do
       student.tag(taggable, with: 'ruby, scheme', on: :tags)
       expect(taggable.owner_tags_on(student, :tags).count).to eq(2)
     end
 
+    it 'returns owner tags on the taggable for an array of contexts' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      student.tag(taggable, with: 'skill_one, skill_two', on: :skills)
+      expect(taggable.owner_tags_on(student, [:tags, :skills]).count).to eq(4)
+      expect(taggable.owner_tags_on(student, [:tags, :skills]).sort == %w(ruby scheme skill_one skill_two))
+    end
+
     it 'should scope objects returned by tagged_with by owners' do
       student.tag(taggable, with: 'ruby, scheme', on: :tags)
       expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: student).count).to eq(1)
@@ -208,4 +229,3 @@ describe 'Single Table Inheritance' do
     end
   end
 end
-

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -83,6 +83,18 @@ describe ActsAsTaggableOn::TagList do
       new_tag_list = tag_list.concat(another_tag_list)
       expect(new_tag_list.class).to eq(ActsAsTaggableOn::TagList)
     end
+
+    context 'without duplicates' do
+      let(:arr) { ['crazy', 'alien'] }
+      let(:another_tag_list) { ActsAsTaggableOn::TagList.new(*arr) }
+      it 'adds other list' do
+        expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
+      end
+
+      it 'adds other array' do
+        expect(tag_list.concat(arr)).to eq(%w[awesome radical crazy alien])
+      end
+    end
   end
 
   describe '#to_s' do
@@ -92,7 +104,7 @@ describe ActsAsTaggableOn::TagList do
 
     it 'should be able to call to_s on a frozen tag list' do
       tag_list.freeze
-      expect(-> { tag_list.add('cool', 'rad,bodacious') }).to raise_error
+      expect(-> { tag_list.add('cool', 'rad,bodacious') }).to raise_error(RuntimeError)
       expect(-> { tag_list.to_s }).to_not raise_error
     end
   end
@@ -114,6 +126,20 @@ describe ActsAsTaggableOn::TagList do
 
       ActsAsTaggableOn.force_lowercase = false
     end
+
+    it 'should ignore case when removing duplicates if strict_case_match is false' do
+      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
+
+      expect(tag_list.to_s).to eq('Junglist, Massive')
+    end
+
+    it 'should not ignore case when removing duplicates if strict_case_match is true' do
+      ActsAsTaggableOn.strict_case_match = true
+      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
+
+      expect(tag_list.to_s).to eq('Junglist, JUNGLIST, Massive, MASSIVE')
+      ActsAsTaggableOn.strict_case_match = false
+    end
   end
 
   describe 'custom parser' do

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
 
 
@@ -55,6 +55,36 @@ describe ActsAsTaggableOn::Tag do
     end
   end
 
+  describe 'for context' do
+    before(:each) do
+      @user.skill_list.add('ruby')
+      @user.save
+    end
+
+    it 'should return tags that have been used in the given context' do
+      expect(ActsAsTaggableOn::Tag.for_context('skills').pluck(:name)).to include('ruby')
+    end
+
+    it 'should not return tags that have been used in other contexts' do
+      expect(ActsAsTaggableOn::Tag.for_context('needs').pluck(:name)).to_not include('ruby')
+    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
 
@@ -119,6 +123,21 @@ describe 'Taggable' do
     expect(@taggable.tag_counts_on(:tags).length).to eq(2)
   end
 
+  context 'tag_counts on a collection' do
+    context 'a select clause is specified on the collection' do
+      it 'should return tag counts without raising an error' do
+        expect(TaggableModel.tag_counts_on(:tags)).to be_empty
+
+        @taggable.tag_list = %w(awesome epic)
+        @taggable.save
+
+        expect {
+          expect(TaggableModel.select(:name).tag_counts_on(:tags).length).to eq(2)
+        }.not_to raise_error
+      end
+    end
+  end
+
   it 'should have tags_on' do
     expect(TaggableModel.tags_on(:tags)).to be_empty
 
@@ -185,8 +204,8 @@ describe 'Taggable' do
     @taggables[1].skill_list = 'css'
     @taggables.each { |taggable| taggable.save }
 
-    @found_taggables_by_tag = TaggableModel.joins(:tags).where(tags: {name: ['bob']})
-    @found_taggables_by_skill = TaggableModel.joins(:skills).where(tags: {name: ['ruby']})
+    @found_taggables_by_tag = TaggableModel.joins(:tags).where(ActsAsTaggableOn.tags_table => {name: ['bob']})
+    @found_taggables_by_skill = TaggableModel.joins(:skills).where(ActsAsTaggableOn.tags_table => {name: ['ruby']})
 
     expect(@found_taggables_by_tag).to include @taggables[0]
     expect(@found_taggables_by_tag).to_not include @taggables[1]
@@ -226,11 +245,13 @@ describe 'Taggable' do
   it "should be able to find a tag using dates" do
     @taggable.skill_list = "ruby"
     @taggable.save
+    today = Date.today.to_time.utc
+    tomorrow = Date.tomorrow.to_time.utc
 
-    expect(TaggableModel.tagged_with("ruby", :start_at => Date.today, :end_at => Date.tomorrow).count).to eq(1)
+    expect(TaggableModel.tagged_with("ruby", :start_at => today, :end_at => tomorrow).count).to eq(1)
   end
 
-    it "shouldn't be able to find a tag outside date range" do
+  it "shouldn't be able to find a tag outside date range" do
     @taggable.skill_list = "ruby"
     @taggable.save
 
@@ -238,14 +259,17 @@ describe 'Taggable' do
   end
 
   it 'should be able to find by tag with context' do
-    @taggable.skill_list = 'ruby, rails, css'
-    @taggable.tag_list = 'bob, charlie'
+    @taggable.skill_list = 'ruby, rails, css, julia'
+    @taggable.tag_list = 'bob, charlie, julia'
     @taggable.save
 
     expect(TaggableModel.tagged_with('ruby').first).to eq(@taggable)
     expect(TaggableModel.tagged_with('ruby, css').first).to eq(@taggable)
     expect(TaggableModel.tagged_with('bob', on: :skills).first).to_not eq(@taggable)
     expect(TaggableModel.tagged_with('bob', on: :tags).first).to eq(@taggable)
+    expect(TaggableModel.tagged_with('julia', on: :skills).size).to eq(1)
+    expect(TaggableModel.tagged_with('julia', on: :tags).size).to eq(1)
+    expect(TaggableModel.tagged_with('julia', on: nil).size).to eq(2)
   end
 
   it 'should not care about case' do
@@ -318,7 +342,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
     expect(TaggableModel.all_tag_counts).to_not be_empty
-    expect(TaggableModel.all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
+    expect(TaggableModel.all_tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(3) # ruby
   end
 
   it 'should be able to get all tags on model as whole' do
@@ -327,7 +351,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
     expect(TaggableModel.all_tags).to_not be_empty
-    expect(TaggableModel.all_tags(order: 'tags.id').first.name).to eq('ruby')
+    expect(TaggableModel.all_tags(order: "#{ActsAsTaggableOn.tags_table}.id").first.name).to eq('ruby')
   end
 
   it 'should be able to use named scopes to chain tag finds by any tags by context' do
@@ -349,7 +373,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').tag_counts(order: 'tags.id').first.count).to eq(2) # ruby
+    expect(TaggableModel.tagged_with('ruby').tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(2) # ruby
     expect(TaggableModel.tagged_with('ruby').skill_counts.first.count).to eq(1) # ruby
   end
 
@@ -358,7 +382,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
+    expect(TaggableModel.tagged_with('ruby').all_tag_counts(order: "#{ActsAsTaggableOn.tags_table}.id").first.count).to eq(3) # ruby
   end
 
   it 'should be able to get all scoped tags' do
@@ -366,7 +390,7 @@ describe 'Taggable' do
     TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
     TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    expect(TaggableModel.tagged_with('ruby').all_tags(order: 'tags.id').first.name).to eq('ruby')
+    expect(TaggableModel.tagged_with('ruby').all_tags(order: "#{ActsAsTaggableOn.tags_table}.id").first.name).to eq('ruby')
   end
 
   it 'should only return tag counts for the available scope' do
@@ -380,7 +404,6 @@ describe 'Taggable' do
     # Test specific join syntaxes:
     frank.untaggable_models.create!
     expect(TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tag_counts.size).to eq(2)
-    expect(TaggableModel.tagged_with('rails').joins(untaggable_models: :taggable_model).all_tag_counts.size).to eq(2)
     expect(TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tag_counts.size).to eq(2)
   end
 
@@ -395,7 +418,6 @@ describe 'Taggable' do
     # Test specific join syntaxes:
     frank.untaggable_models.create!
     expect(TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tags.size).to eq(2)
-    expect(TaggableModel.tagged_with('rails').joins(untaggable_models: :taggable_model).all_tags.size).to eq(2)
     expect(TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tags.size).to eq(2)
   end
 
@@ -459,7 +481,7 @@ describe 'Taggable' do
 
       expect(TaggableModel.tagged_with(%w(bob tricia), wild: true, any: true).to_a.sort_by { |o| o.id }).to eq([bob, frank, steve])
       expect(TaggableModel.tagged_with(%w(bob tricia), wild: true, exclude: true).to_a).to eq([jim])
-      expect(TaggableModel.tagged_with('ji', wild: true, any: true).to_a).to eq([frank, jim])
+      expect(TaggableModel.tagged_with('ji', wild: true, any: true).to_a).to match_array([frank, jim])
     end
   end
 
@@ -523,7 +545,7 @@ describe 'Taggable' do
 
   it 'should not delete tags if not updated' do
     model = TaggableModel.create(name: 'foo', tag_list: 'ruby, rails, programming')
-    model.update_attributes(name: 'bar')
+    model.update(name: 'bar')
     model.reload
     expect(model.tag_list.sort).to eq(%w(ruby rails programming).sort)
   end
@@ -654,15 +676,15 @@ describe 'Taggable' do
       # NOTE: type column supports an STI Tag subclass in the test suite, though
       # isn't included by default in the migration generator
       expect(@taggable.grouped_column_names_for(ActsAsTaggableOn::Tag))
-      .to eq('tags.id, tags.name, tags.taggings_count, tags.type')
+      .to eq("#{ActsAsTaggableOn.tags_table}.id, #{ActsAsTaggableOn.tags_table}.name, #{ActsAsTaggableOn.tags_table}.taggings_count, #{ActsAsTaggableOn.tags_table}.type")
     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
 
@@ -743,7 +765,6 @@ describe 'Taggable' do
 
     context 'Model.limit(x).tag_counts.sum(:tags_count)' do
       it 'should not break on Mysql' do
-        # Activerecord 3.2 return a string
         expect(TaggableModel.limit(2).tag_counts.sum('tags_count').to_i).to eq(5)
       end
     end

data/spec/acts_as_taggable_on/tagger_spec.rb

@@ -112,7 +112,7 @@ describe 'Tagger' do
   end
 
   it 'should not lose tags' do
-    @taggable.update_attributes(tag_list: 'ruby')
+    @taggable.update(tag_list: 'ruby')
     @user.tag(@taggable, with: 'ruby, scheme', on: :tags)
 
     [@taggable, @user].each(&:reload)
@@ -120,7 +120,7 @@ describe 'Tagger' do
     expect(@taggable.all_tags_list.sort).to eq(%w(ruby scheme).sort)
 
     expect(-> {
-      @taggable.update_attributes(tag_list: '')
+      @taggable.update(tag_list: '')
     }).to change(ActsAsTaggableOn::Tagging, :count).by(-1)
 
     expect(@taggable.tag_list).to be_empty

data/spec/acts_as_taggable_on/tagging_spec.rb

@@ -49,15 +49,95 @@ describe ActsAsTaggableOn::Tagging do
     ActsAsTaggableOn.remove_unused_tags = previous_setting
   end
 
-  pending 'context scopes' do
-    describe '.by_context'
-
-    describe '.by_contexts'
-
-    describe '.owned_by'
+  it 'should destroy unused tags after tagging destroyed when not using tags_counter' do
+    remove_unused_tags_previous_setting = ActsAsTaggableOn.remove_unused_tags
+    tags_counter_previous_setting = ActsAsTaggableOn.tags_counter
+    ActsAsTaggableOn.remove_unused_tags = true
+    ActsAsTaggableOn.tags_counter = false
 
-    describe '.not_owned'
+    ActsAsTaggableOn::Tag.destroy_all
+    @taggable = TaggableModel.create(name: 'Bob Jones')
+    @taggable.update_attribute :tag_list, 'aaa,bbb,ccc'
+    @taggable.update_attribute :tag_list, ''
+    expect(ActsAsTaggableOn::Tag.count).to eql(0)
 
+    ActsAsTaggableOn.remove_unused_tags = remove_unused_tags_previous_setting
+    ActsAsTaggableOn.tags_counter = tags_counter_previous_setting
   end
 
+  describe 'context scopes' do
+    before do
+      @tagging_2 = ActsAsTaggableOn::Tagging.new
+      @tagging_3 = ActsAsTaggableOn::Tagging.new
+
+      @tagger = User.new
+      @tagger_2 = User.new
+
+      @tagging.taggable = TaggableModel.create(name: "Black holes")
+      @tagging.tag = ActsAsTaggableOn::Tag.create(name: "Physics")
+      @tagging.tagger = @tagger
+      @tagging.context = 'Science'
+      @tagging.tenant = 'account1'
+      @tagging.save
+
+      @tagging_2.taggable = TaggableModel.create(name: "Satellites")
+      @tagging_2.tag = ActsAsTaggableOn::Tag.create(name: "Technology")
+      @tagging_2.tagger = @tagger_2
+      @tagging_2.context = 'Science'
+      @tagging_2.tenant = 'account1'
+      @tagging_2.save
+
+      @tagging_3.taggable = TaggableModel.create(name: "Satellites")
+      @tagging_3.tag = ActsAsTaggableOn::Tag.create(name: "Engineering")
+      @tagging_3.tagger = @tagger_2
+      @tagging_3.context = 'Astronomy'
+      @tagging_3.save
+
+    end
+
+    describe '.owned_by' do
+      it "should belong to a specific user" do
+        expect(ActsAsTaggableOn::Tagging.owned_by(@tagger).first).to eq(@tagging)
+      end
+    end
+
+    describe '.by_context' do
+      it "should be found by context" do
+        expect(ActsAsTaggableOn::Tagging.by_context('Science').length).to eq(2);
+      end
+    end
+
+    describe '.by_contexts' do
+      it "should find taggings by contexts" do
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).first).to eq(@tagging);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).second).to eq(@tagging_2);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).third).to eq(@tagging_3);
+        expect(ActsAsTaggableOn::Tagging.by_contexts(['Science', 'Astronomy']).length).to eq(3);
+      end
+    end
+
+    describe '.by_tenant' do
+      it "should find taggings by tenant" do
+        expect(ActsAsTaggableOn::Tagging.by_tenant('account1').length).to eq(2);
+        expect(ActsAsTaggableOn::Tagging.by_tenant('account1').first).to eq(@tagging);
+        expect(ActsAsTaggableOn::Tagging.by_tenant('account1').second).to eq(@tagging_2);
+      end
+    end
+
+    describe '.not_owned' do
+      before do
+        @tagging_4 = ActsAsTaggableOn::Tagging.new
+        @tagging_4.taggable = TaggableModel.create(name: "Gravity")
+        @tagging_4.tag = ActsAsTaggableOn::Tag.create(name: "Space")
+        @tagging_4.context = "Science"
+        @tagging_4.save
+      end
+
+      it "should found the taggings that do not have owner" do
+        expect(ActsAsTaggableOn::Tagging.all.length).to eq(4)
+        expect(ActsAsTaggableOn::Tagging.not_owned.length).to eq(1)
+        expect(ActsAsTaggableOn::Tagging.not_owned.first).to eq(@tagging_4)
+      end
+    end
+  end
 end

data/spec/internal/app/models/altered_inheriting_taggable_model.rb

@@ -1,3 +1,5 @@
+require_relative 'taggable_model'
+
 class AlteredInheritingTaggableModel < TaggableModel
   acts_as_taggable_on :parts
 end