acts-as-taggable-on 2.0.0 → 3.2.2

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -1,265 +1,259 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+# coding: utf-8
+require 'spec_helper'
 
-describe "Acts As Taggable On" do
-  before(:each) do
-    clean_database!
-  end
+describe 'Acts As Taggable On' do
 
   it "should provide a class method 'taggable?' that is false for untaggable models" do
-    UntaggableModel.should_not be_taggable
+    expect(UntaggableModel).to_not be_taggable
+  end
+
+  describe 'Taggable Method Generation To Preserve Order' do
+    before(:each) do
+      TaggableModel.tag_types = []
+      TaggableModel.preserve_tag_order = false
+      TaggableModel.acts_as_ordered_taggable_on(:ordered_tags)
+      @taggable = TaggableModel.new(name: 'Bob Jones')
+    end
+
+    it "should respond 'true' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_truthy
+    end
   end
 
-  describe "Taggable Method Generation" do
+  describe 'Taggable Method Generation' do
     before(:each) do
-      [TaggableModel, Tag, Tagging, TaggableUser].each(&:delete_all)
-      @taggable = TaggableModel.new(:name => "Bob Jones")
+      TaggableModel.tag_types = []
+      TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
+      @taggable = TaggableModel.new(name: 'Bob Jones')
     end
 
     it "should respond 'true' to taggable?" do
-      @taggable.class.should be_taggable
+      expect(@taggable.class).to be_taggable
     end
 
-    it "should create a class attribute for tag types" do
-      @taggable.class.should respond_to(:tag_types)
+    it 'should create a class attribute for tag types' do
+      expect(@taggable.class).to respond_to(:tag_types)
     end
 
-    it "should create an instance attribute for tag types" do
-      @taggable.should respond_to(:tag_types)
+    it 'should create an instance attribute for tag types' do
+      expect(@taggable).to respond_to(:tag_types)
     end
-    
-    it "should have all tag types" do
-      @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
+
+    it 'should have all tag types' do
+      expect(@taggable.tag_types).to eq([:tags, :languages, :skills, :needs, :offerings])
     end
 
-    it "should generate an association for each tag type" do
-      @taggable.should respond_to(:tags, :skills, :languages)
+    it 'should create a class attribute for preserve tag order' do
+      expect(@taggable.class).to respond_to(:preserve_tag_order?)
     end
 
-    it "should add tagged_with and tag_counts to singleton" do
-      TaggableModel.should respond_to(:tagged_with, :tag_counts)
+    it 'should create an instance attribute for preserve tag order' do
+      expect(@taggable).to respond_to(:preserve_tag_order?)
     end
 
-    it "should generate a tag_list accessor/setter for each tag type" do
-      @taggable.should respond_to(:tag_list, :skill_list, :language_list)
-      @taggable.should respond_to(:tag_list=, :skill_list=, :language_list=)
+    it "should respond 'false' to preserve_tag_order?" do
+      expect(@taggable.class.preserve_tag_order?).to be_falsy
     end
-    
-    it "should generate a tag_list accessor, that includes owned tags, for each tag type" do
-      @taggable.should respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
+
+    it 'should generate an association for each tag type' do
+      expect(@taggable).to respond_to(:tags, :skills, :languages)
     end
-  end
 
-  describe "Single Table Inheritance" do
-    before do
-      @taggable = TaggableModel.new(:name => "taggable")
-      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
-      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
+    it 'should add tagged_with and tag_counts to singleton' do
+      expect(TaggableModel).to respond_to(:tagged_with, :tag_counts)
     end
-  
-    it "should pass on tag contexts to STI-inherited models" do
-      @inherited_same.should respond_to(:tag_list, :skill_list, :language_list)
-      @inherited_different.should respond_to(:tag_list, :skill_list, :language_list)
+
+    it 'should generate a tag_list accessor/setter for each tag type' do
+      expect(@taggable).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(@taggable).to respond_to(:tag_list=, :skill_list=, :language_list=)
     end
-  
-    it "should have tag contexts added in altered STI models" do
-      @inherited_different.should respond_to(:part_list)
+
+    it 'should generate a tag_list accessor, that includes owned tags, for each tag type' do
+      expect(@taggable).to respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
     end
   end
-  
-  describe "Reloading" do
-    it "should save a model instantiated by Model.find" do
-      taggable = TaggableModel.create!(:name => "Taggable")
+
+  describe 'Reloading' do
+    it 'should save a model instantiated by Model.find' do
+      taggable = TaggableModel.create!(name: 'Taggable')
       found_taggable = TaggableModel.find(taggable.id)
       found_taggable.save
     end
   end
 
-  describe "Related Objects" do
-    it "should find related objects based on tag names on context" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-      taggable3 = TaggableModel.create!(:name => "Taggable 3")
-  
-      taggable1.tag_list = "one, two"
-      taggable1.save
-  
-      taggable2.tag_list = "three, four"
-      taggable2.save
-  
-      taggable3.tag_list = "one, four"
-      taggable3.save
-  
-      taggable1.find_related_tags.should include(taggable3)
-      taggable1.find_related_tags.should_not include(taggable2)
-    end
-  
-    it "should find other related objects based on tag names on context" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
-      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
-  
-      taggable1.tag_list = "one, two"
-      taggable1.save
-  
-      taggable2.tag_list = "three, four"
-      taggable2.save
-  
-      taggable3.tag_list = "one, four"
-      taggable3.save
-  
-      taggable1.find_related_tags_for(OtherTaggableModel).should include(taggable3)
-      taggable1.find_related_tags_for(OtherTaggableModel).should_not include(taggable2)
-    end
-  
-    it "should not include the object itself in the list of related objects" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-  
-      taggable1.tag_list = "one"
-      taggable1.save
-  
-      taggable2.tag_list = "one, two"
-      taggable2.save
-  
-      taggable1.find_related_tags.should include(taggable2)
-      taggable1.find_related_tags.should_not include(taggable1)
-    end
-  end
+  describe 'Matching Contexts' do
+    it 'should find objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
+      taggable3 = TaggableModel.create!(name: 'Taggable 3')
 
-  describe "Matching Contexts" do
-    it "should find objects with tags of matching contexts" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-      taggable3 = TaggableModel.create!(:name => "Taggable 3")
-  
-      taggable1.offering_list = "one, two"
+      taggable1.offering_list = 'one, two'
       taggable1.save!
-  
-      taggable2.need_list = "one, two"
+
+      taggable2.need_list = 'one, two'
       taggable2.save!
-  
-      taggable3.offering_list = "one, two"
+
+      taggable3.offering_list = 'one, two'
       taggable3.save!
-  
-      taggable1.find_matching_contexts(:offerings, :needs).should include(taggable2)
-      taggable1.find_matching_contexts(:offerings, :needs).should_not include(taggable3)
+
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts(:offerings, :needs)).to_not include(taggable3)
     end
-  
-    it "should find other related objects with tags of matching contexts" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = OtherTaggableModel.create!(:name => "Taggable 2")
-      taggable3 = OtherTaggableModel.create!(:name => "Taggable 3")
-  
-      taggable1.offering_list = "one, two"
+
+    it 'should find other related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = OtherTaggableModel.create!(name: 'Taggable 2')
+      taggable3 = OtherTaggableModel.create!(name: 'Taggable 3')
+
+      taggable1.offering_list = 'one, two'
       taggable1.save
-  
-      taggable2.need_list = "one, two"
+
+      taggable2.need_list = 'one, two'
       taggable2.save
-  
-      taggable3.offering_list = "one, two"
+
+      taggable3.offering_list = 'one, two'
       taggable3.save
-  
-      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should include(taggable2)
-      taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs).should_not include(taggable3)
+
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(OtherTaggableModel, :offerings, :needs)).to_not include(taggable3)
     end
-  
-    it "should not include the object itself in the list of related objects" do
-      taggable1 = TaggableModel.create!(:name => "Taggable 1")
-      taggable2 = TaggableModel.create!(:name => "Taggable 2")
-  
-      taggable1.tag_list = "one"
+
+    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
+      taggable1 = TaggableModel.create!(name: 'Taggable 1')
+      taggable2 = TaggableModel.create!(name: 'Taggable 2')
+
+      taggable1.offering_list = 'one, two'
+      taggable1.need_list = 'one, two'
       taggable1.save
-  
-      taggable2.tag_list = "one, two"
+
+      taggable2.need_list = 'one, two'
       taggable2.save
-  
-      taggable1.find_related_tags.should include(taggable2)
-      taggable1.find_related_tags.should_not include(taggable1)
+
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable2)
+      expect(taggable1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(taggable1)
     end
+
   end
 
   describe 'Tagging Contexts' do
     it 'should eliminate duplicate tagging contexts ' do
       TaggableModel.acts_as_taggable_on(:skills, :skills)
-      TaggableModel.tag_types.freq[:skills].should_not == 3
+      expect(TaggableModel.tag_types.freq[:skills]).to_not eq(3)
     end
 
-    it "should not contain embedded/nested arrays" do
+    it 'should not contain embedded/nested arrays' do
       TaggableModel.acts_as_taggable_on([:array], [:array])
-      TaggableModel.tag_types.freq[[:array]].should == 0
+      expect(TaggableModel.tag_types.freq[[:array]]).to eq(0)
     end
 
-    it "should _flatten_ the content of arrays" do
+    it 'should _flatten_ the content of arrays' do
       TaggableModel.acts_as_taggable_on([:array], [:array])
-      TaggableModel.tag_types.freq[:array].should == 1
+      expect(TaggableModel.tag_types.freq[:array]).to eq(1)
     end
 
-    it "should not raise an error when passed nil" do
-      lambda {
-        TaggableModel.acts_as_taggable_on()
-      }.should_not raise_error
+    it 'should not raise an error when passed nil' do
+      expect(-> {
+        TaggableModel.acts_as_taggable_on
+      }).to_not raise_error
     end
 
-    it "should not raise an error when passed [nil]" do
-      lambda {
+    it 'should not raise an error when passed [nil]' do
+      expect(-> {
         TaggableModel.acts_as_taggable_on([nil])
-      }.should_not raise_error
+      }).to_not raise_error
     end
   end
-  
-  describe 'Caching' do
-    before(:each) do
-      @taggable = CachedModel.new(:name => "Bob Jones")  
-    end
-    
-    it "should add saving of tag lists and cached tag lists to the instance" do
-      @taggable.should respond_to(:save_cached_tag_list)
-      @taggable.should respond_to(:save_tags)
-    end  
-
-    it "should generate a cached column checker for each tag type" do
-      CachedModel.should respond_to(:caching_tag_list?)
-    end  
-    
-    it 'should not have cached tags' do
-      @taggable.cached_tag_list.should be_blank  
-    end
-    
-    it 'should cache tags' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.cached_tag_list.should == 'awesome, epic'
+
+  context 'when tagging context ends in an "s" when singular (ex. "status", "glass", etc.)' do
+    describe 'caching' do
+      before  { @taggable = OtherCachedModel.new(name: 'John Smith') }
+      subject { @taggable }
+
+      it { should respond_to(:save_cached_tag_list) }
+      its(:cached_language_list) { should be_blank }
+      its(:cached_status_list)   { should be_blank }
+      its(:cached_glass_list)    { should be_blank }
+
+      context 'language taggings cache after update' do
+        before  { @taggable.update_attributes(language_list: 'ruby, .net') }
+        subject { @taggable }
+
+        its(:language_list)        { should == ['ruby', '.net']}
+        its(:cached_language_list) { should == 'ruby, .net' }           # passes
+        its(:instance_variables)   { should     include((RUBY_VERSION < '1.9' ? '@language_list' : :@language_list)) }
+      end
+
+      context 'status taggings cache after update' do
+        before  { @taggable.update_attributes(status_list: 'happy, married') }
+        subject { @taggable }
+
+        its(:status_list)        { should     == ['happy', 'married'] }
+        its(:cached_status_list) { should     == 'happy, married'     } # fails
+        its(:cached_status_list) { should_not == ''                   } # fails, is blank
+        its(:instance_variables) { should     include((RUBY_VERSION < '1.9' ? '@status_list' : :@status_list)) }
+        its(:instance_variables) { should_not include((RUBY_VERSION < '1.9' ? '@statu_list' : :@statu_list))  } # fails, note: one "s"
+
+      end
+
+      context 'glass taggings cache after update' do
+        before do
+          @taggable.update_attributes(glass_list: 'rectangle, aviator')
+        end
+
+        subject { @taggable }
+        its(:glass_list)         { should     == ['rectangle', 'aviator'] }
+        its(:cached_glass_list)  { should     == 'rectangle, aviator'     } # fails
+        its(:cached_glass_list)  { should_not == ''                       } # fails, is blank
+        if RUBY_VERSION < '1.9'
+          its(:instance_variables) { should     include('@glass_list')      }
+          its(:instance_variables) { should_not include('@glas_list')       } # fails, note: one "s"
+        else
+          its(:instance_variables) { should     include(:@glass_list)      }
+          its(:instance_variables) { should_not include(:@glas_list)       } # fails, note: one "s"
+        end
+
+      end
     end
-    
-    it 'should keep the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable)  
-      @taggable.save!
-      @taggable.cached_tag_list.should == 'awesome, epic'   
+  end
+
+  describe 'taggings' do
+    before(:each) do
+      @taggable = TaggableModel.new(name: 'Art Kram')
     end
-    
-    it 'should update the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.update_attributes(:tag_list => 'awesome')
-      @taggable.cached_tag_list.should == 'awesome'      
+
+    it 'should return no taggings' do
+      expect(@taggable.taggings).to be_empty
     end
-    
-    it 'should remove the cache' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable.update_attributes(:tag_list => '')
-      @taggable.cached_tag_list.should be_blank  
+  end
+
+  describe '@@remove_unused_tags' do
+    before do
+      @taggable = TaggableModel.create(name: 'Bob Jones')
+      @tag = ActsAsTaggableOn::Tag.create(name: 'awesome')
+
+      @tagging = ActsAsTaggableOn::Tagging.create(taggable: @taggable, tag: @tag, context: 'tags')
     end
-    
-    it 'should have a tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable.id)
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
+
+    context 'if set to true' do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = true
+      end
+
+      it 'should remove unused tags after removing taggings' do
+        @tagging.destroy
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to be_nil
+      end
     end
-    
-    it 'should keep the tag list' do
-      @taggable.update_attributes(:tag_list => 'awesome, epic')
-      @taggable = CachedModel.find(@taggable.id)
-      @taggable.save!
-      @taggable.tag_list.sort.should == %w(awesome epic).sort
+
+    context 'if set to false' do
+      before do
+        ActsAsTaggableOn.remove_unused_tags = false
+      end
+
+      it 'should not remove unused tags after removing taggings' do
+        @tagging.destroy
+        expect(ActsAsTaggableOn::Tag.find_by_name('awesome')).to eq(@tag)
+      end
     end
   end
 

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -1,114 +1,111 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
-describe "acts_as_tagger" do
-  before(:each) do
-    clean_database!
-  end
-  
-  context "Tagger Method Generation" do
+describe 'acts_as_tagger' do
+
+  describe 'Tagger Method Generation' do
     before(:each) do
-      @tagger = TaggableUser.new()
+      @tagger = User.new
     end
 
-    it "should add #is_tagger? query method to the class-side" do
-      TaggableUser.should respond_to(:is_tagger?)
+    it 'should add #is_tagger? query method to the class-side' do
+      expect(User).to respond_to(:is_tagger?)
     end
-    
-    it "should return true from the class-side #is_tagger?" do
-      TaggableUser.is_tagger?.should be_true
+
+    it 'should return true from the class-side #is_tagger?' do
+      expect(User.is_tagger?).to be_truthy
     end
-    
-    it "should return false from the base #is_tagger?" do
-      ActiveRecord::Base.is_tagger?.should be_false
+
+    it 'should return false from the base #is_tagger?' do
+      expect(ActiveRecord::Base.is_tagger?).to be_falsy
     end
-    
-    it "should add #is_tagger? query method to the singleton" do
-      @tagger.should respond_to(:is_tagger?)
+
+    it 'should add #is_tagger? query method to the singleton' do
+      expect(@tagger).to respond_to(:is_tagger?)
     end
-    
-    it "should add #tag method on the instance-side" do
-      @tagger.should respond_to(:tag)
+
+    it 'should add #tag method on the instance-side' do
+      expect(@tagger).to respond_to(:tag)
     end
-    
-    it "should generate an association for #owned_taggings and #owned_tags" do
-      @tagger.should respond_to(:owned_taggings, :owned_tags)
+
+    it 'should generate an association for #owned_taggings and #owned_tags' do
+      expect(@tagger).to respond_to(:owned_taggings, :owned_tags)
     end
   end
-  
-  describe "#tag" do
+
+  describe '#tag' do
     context 'when called with a non-existent tag context' do
       before(:each) do
-        @tagger = TaggableUser.new()
-        @taggable = TaggableModel.new(:name=>"Richard Prior")
+        @tagger = User.new
+        @taggable = TaggableModel.new(name: 'Richard Prior')
       end
-      
-      it "should by default not throw an exception " do
-        @taggable.tag_list_on(:foo).should be_empty
-        lambda {
-          @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo)
-        }.should_not raise_error
+
+      it 'should by default not throw an exception ' do
+        expect(@taggable.tag_list_on(:foo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo)
+        }).to_not raise_error
       end
-      
+
       it 'should by default create the tag context on-the-fly' do
-        @taggable.tag_list_on(:here_ond_now).should be_empty
-        @tagger.tag(@taggable, :with=>'that', :on => :here_ond_now)
-        @taggable.tag_list_on(:here_ond_now).should_not include('that')
-        @taggable.all_tags_list_on(:here_ond_now).should include('that')
+        expect(@taggable.tag_list_on(:here_ond_now)).to be_empty
+        @tagger.tag(@taggable, with: 'that', on: :here_ond_now)
+        expect(@taggable.tag_list_on(:here_ond_now)).to_not include('that')
+        expect(@taggable.all_tags_list_on(:here_ond_now)).to include('that')
       end
-      
-      it "should show all the tag list when both public and owned tags exist" do
+
+      it 'should show all the tag list when both public and owned tags exist' do
         @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
-        @taggable.all_tags_on(:tags).map(&:name).sort.should == %w(ruby python java lisp).sort
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.all_tags_on(:tags).map(&:name).sort).to eq(%w(ruby python java lisp).sort)
       end
-      
-      it "should not add owned tags to the common list" do
+
+      it 'should not add owned tags to the common list' do
         @taggable.tag_list = 'ruby, python'
-        @tagger.tag(@taggable, :with => 'java, lisp', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
-        @tagger.tag(@taggable, :with => '', :on => :tags)
-        @taggable.tag_list.should == %w(ruby python)
+        @tagger.tag(@taggable, with: 'java, lisp', on: :tags)
+        expect(@taggable.tag_list).to eq(%w(ruby python))
+        @tagger.tag(@taggable, with: '', on: :tags)
+        expect(@taggable.tag_list).to eq(%w(ruby python))
       end
-      
-      it "should throw an exception when the default is over-ridden" do
-        @taggable.tag_list_on(:foo_boo).should be_empty
-        lambda {
-          @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false)
-        }.should raise_error        
+
+      it 'should throw an exception when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        expect(-> {
+          @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false)
+        }).to raise_error
       end
 
-      it "should not create the tag context on-the-fly when the default is over-ridden" do
-        @taggable.tag_list_on(:foo_boo).should be_empty
-        @tagger.tag(@taggable, :with=>'this, and, that', :on=>:foo_boo, :force=>false) rescue
-        @taggable.tag_list_on(:foo_boo).should be_empty
+      it 'should not create the tag context on-the-fly when the default is over-ridden' do
+        expect(@taggable.tag_list_on(:foo_boo)).to be_empty
+        @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false) rescue
+            expect(@taggable.tag_list_on(:foo_boo)).to be_empty
       end
     end
-    
-    context "when called by multiple tagger's" do
+
+    describe "when called by multiple tagger's" do
       before(:each) do
-        @user_x = TaggableUser.create(:name => "User X")
-        @user_y = TaggableUser.create(:name => "User Y")
-        @taggable = TaggableModel.create(:name => 'acts_as_taggable_on', :tag_list => 'plugin')
-        
-        @user_x.tag(@taggable, :with => 'ruby, rails',  :on => :tags)
-        @user_y.tag(@taggable, :with => 'ruby, plugin', :on => :tags)
-
-        @user_y.tag(@taggable, :with => '', :on => :tags)
-        @user_y.tag(@taggable, :with => '', :on => :tags)
+        @user_x = User.create(name: 'User X')
+        @user_y = User.create(name: 'User Y')
+        @taggable = TaggableModel.create(name: 'acts_as_taggable_on', tag_list: 'plugin')
+
+        @user_x.tag(@taggable, with: 'ruby, rails', on: :tags)
+        @user_y.tag(@taggable, with: 'ruby, plugin', on: :tags)
+
+        @user_y.tag(@taggable, with: '', on: :tags)
+        @user_y.tag(@taggable, with: '', on: :tags)
       end
-      
-      it "should delete owned tags" do        
-        @user_y.owned_tags.should == []
+
+      it 'should delete owned tags' do
+        expect(@user_y.owned_tags).to be_empty
       end
-      
-      it "should not delete other taggers tags" do
-        @user_x.owned_tags.should have(2).items
+
+      it 'should not delete other taggers tags' do
+        expect(@user_x.owned_tags.count).to eq(2)
       end
-      
-      it "should not delete original tags" do
-        @taggable.all_tags_list_on(:tags).should include('plugin')
+
+      it 'should not delete original tags' do
+        expect(@taggable.all_tags_list_on(:tags)).to include('plugin')
       end
     end
   end
 
-end
+end