acts-as-taggable-on 3.1.1 → 3.2.2

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -2,124 +2,156 @@
 require 'spec_helper'
 
 describe ActsAsTaggableOn::TagList do
-  let(:tag_list) { ActsAsTaggableOn::TagList.new("awesome","radical") }
+  let(:tag_list) { ActsAsTaggableOn::TagList.new('awesome', 'radical') }
+  let(:another_tag_list) { ActsAsTaggableOn::TagList.new('awesome','crazy', 'alien') }
 
   it { should be_kind_of Array }
 
-  it "#from should return empty array if empty array is passed" do
-    ActsAsTaggableOn::TagList.from([]).should be_empty
+  it '#from should return empty array if empty array is passed' do
+    expect(ActsAsTaggableOn::TagList.from([])).to be_empty
   end
 
-  describe "#add" do
-    it "should be able to be add a new tag word" do
-      tag_list.add("cool")
-      tag_list.include?("cool").should be_true
+  describe '#add' do
+    it 'should be able to be add a new tag word' do
+      tag_list.add('cool')
+      expect(tag_list.include?('cool')).to be_truthy
     end
 
-    it "should be able to add delimited lists of words" do
-      tag_list.add("cool, wicked", :parse => true)
-      tag_list.should include("cool", "wicked")
+    it 'should be able to add delimited lists of words' do
+      tag_list.add('cool, wicked', parse: true)
+      expect(tag_list).to include('cool', 'wicked')
     end
 
-    it "should be able to add delimited list of words with quoted delimiters" do
-      tag_list.add("'cool, wicked', \"really cool, really wicked\"", :parse => true)
-      tag_list.should include("cool, wicked", "really cool, really wicked")
+    it 'should be able to add delimited list of words with quoted delimiters' do
+      tag_list.add("'cool, wicked', \"really cool, really wicked\"", parse: true)
+      expect(tag_list).to include('cool, wicked', 'really cool, really wicked')
     end
 
-    it "should be able to handle other uses of quotation marks correctly" do
-      tag_list.add("john's cool car, mary's wicked toy", :parse => true)
-      tag_list.should include("john's cool car", "mary's wicked toy")
+    it 'should be able to handle other uses of quotation marks correctly' do
+      tag_list.add("john's cool car, mary's wicked toy", parse: true)
+      expect(tag_list).to include("john's cool car", "mary's wicked toy")
     end
 
-    it "should be able to add an array of words" do
-      tag_list.add(["cool", "wicked"], :parse => true)
-      tag_list.should include("cool", "wicked")
+    it 'should be able to add an array of words' do
+      tag_list.add(%w(cool wicked), parse: true)
+      expect(tag_list).to include('cool', 'wicked')
     end
 
-    it "should quote escape tags with commas in them" do
-      tag_list.add("cool","rad,bodacious")
-      tag_list.to_s.should == "awesome, radical, cool, \"rad,bodacious\""
+    it 'should quote escape tags with commas in them' do
+      tag_list.add('cool', 'rad,bodacious')
+      expect(tag_list.to_s).to eq("awesome, radical, cool, \"rad,bodacious\"")
     end
 
   end
 
-  describe "#remove" do
-    it "should be able to remove words" do
-      tag_list.remove("awesome")
-      tag_list.should_not include("awesome")
+  describe '#remove' do
+    it 'should be able to remove words' do
+      tag_list.remove('awesome')
+      expect(tag_list).to_not include('awesome')
     end
 
-    it "should be able to remove delimited lists of words" do
-      tag_list.remove("awesome, radical", :parse => true)
-      tag_list.should be_empty
+    it 'should be able to remove delimited lists of words' do
+      tag_list.remove('awesome, radical', parse: true)
+      expect(tag_list).to be_empty
     end
 
-    it "should be able to remove an array of words" do
-      tag_list.remove(["awesome", "radical"], :parse => true)
-      tag_list.should be_empty
+    it 'should be able to remove an array of words' do
+      tag_list.remove(%w(awesome radical), parse: true)
+      expect(tag_list).to be_empty
     end
   end
 
-  describe "#to_s" do
-    it "should give a delimited list of words when converted to string" do
-      tag_list.to_s.should == "awesome, radical"
+  describe '#+' do
+    it 'should not have duplicate tags' do
+      new_tag_list = tag_list + another_tag_list
+      expect(tag_list).to eq(%w[awesome radical])
+      expect(another_tag_list).to eq(%w[awesome crazy alien])
+      expect(new_tag_list).to eq(%w[awesome radical crazy alien])
     end
 
-    it "should be able to call to_s on a frozen tag list" do
+    it 'should have class : ActsAsTaggableOn::TagList' do
+      new_tag_list = tag_list + another_tag_list
+      expect(new_tag_list.class).to eq(ActsAsTaggableOn::TagList)
+    end
+  end
+
+  describe '#concat' do
+    it 'should not have duplicate tags' do
+      expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
+    end
+
+    it 'should have class : ActsAsTaggableOn::TagList' do
+      new_tag_list = tag_list.concat(another_tag_list)
+      expect(new_tag_list.class).to eq(ActsAsTaggableOn::TagList)
+    end
+  end
+
+  describe '#to_s' do
+    it 'should give a delimited list of words when converted to string' do
+      expect(tag_list.to_s).to eq('awesome, radical')
+    end
+
+    it 'should be able to call to_s on a frozen tag list' do
       tag_list.freeze
-      lambda { tag_list.add("cool","rad,bodacious") }.should raise_error
-      lambda { tag_list.to_s }.should_not raise_error
+      expect(-> { tag_list.add('cool', 'rad,bodacious') }).to raise_error
+      expect(-> { tag_list.to_s }).to_not raise_error
     end
   end
 
-  describe "cleaning" do
-    it "should parameterize if force_parameterize is set to true" do
+  describe 'cleaning' do
+    it 'should parameterize if force_parameterize is set to true' do
       ActsAsTaggableOn.force_parameterize = true
-      tag_list = ActsAsTaggableOn::TagList.new("awesome()","radical)(cc")
+      tag_list = ActsAsTaggableOn::TagList.new('awesome()', 'radical)(cc')
 
-      tag_list.to_s.should == "awesome, radical-cc"
+      expect(tag_list.to_s).to eq('awesome, radical-cc')
       ActsAsTaggableOn.force_parameterize = false
     end
 
-    it "should lowercase if force_lowercase is set to true" do
+    it 'should lowercase if force_lowercase is set to true' do
       ActsAsTaggableOn.force_lowercase = true
 
-      tag_list = ActsAsTaggableOn::TagList.new("aweSomE","RaDicaL","Entrée")
-      tag_list.to_s.should == "awesome, radical, entrée"
+      tag_list = ActsAsTaggableOn::TagList.new('aweSomE', 'RaDicaL', 'Entrée')
+      expect(tag_list.to_s).to eq('awesome, radical, entrée')
 
       ActsAsTaggableOn.force_lowercase = false
     end
 
   end
 
-  describe "Multiple Delimiter" do
-    before do 
+  describe 'Multiple Delimiter' do
+    before do
       @old_delimiter = ActsAsTaggableOn.delimiter
     end
 
-    after do 
+    after do
       ActsAsTaggableOn.delimiter = @old_delimiter
     end
 
-    it "should separate tags by delimiters" do
+    it 'should separate tags by delimiters' do
       ActsAsTaggableOn.delimiter = [',', ' ', '\|']
-      tag_list = ActsAsTaggableOn::TagList.from "cool, data|I have"
-      tag_list.to_s.should == 'cool, data, I, have'
+      tag_list = ActsAsTaggableOn::TagList.from 'cool, data|I have'
+      expect(tag_list.to_s).to eq('cool, data, I, have')
     end
 
-    it "should escape quote" do 
+    it 'should escape quote' do
       ActsAsTaggableOn.delimiter = [',', ' ', '\|']
       tag_list = ActsAsTaggableOn::TagList.from "'I have'|cool, data"
-      tag_list.to_s.should == '"I have", cool, data'
+      expect(tag_list.to_s).to eq('"I have", cool, data')
 
       tag_list = ActsAsTaggableOn::TagList.from '"I, have"|cool, data'
-      tag_list.to_s.should == '"I, have", cool, data'
+      expect(tag_list.to_s).to eq('"I, have", cool, data')
     end
 
-    it "should work for utf8 delimiter and long delimiter" do 
+    it 'should work for utf8 delimiter and long delimiter' do
       ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
-      tag_list = ActsAsTaggableOn::TagList.from "我的东西可能是不见了，还好有备份"
-      tag_list.to_s.should == "我， 东西， 不见了， 还好有备份"
+      tag_list = ActsAsTaggableOn::TagList.from '我的东西可能是不见了，还好有备份'
+      expect(tag_list.to_s).to eq('我， 东西， 不见了， 还好有备份')
+    end
+
+    it 'should work for multiple quoted tags' do
+      ActsAsTaggableOn.delimiter = [',']
+      tag_list = ActsAsTaggableOn::TagList.from '"Ruby Monsters","eat Katzenzungen"'
+      expect(tag_list.to_s).to eq('Ruby Monsters, eat Katzenzungen')
     end
   end
 

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -3,207 +3,219 @@ require 'spec_helper'
 require 'db/migrate/2_add_missing_unique_indices.rb'
 
 shared_examples_for 'without unique index' do
-  before { AddMissingUniqueIndices.down }
-  after { ActsAsTaggableOn::Tag.delete_all; AddMissingUniqueIndices.up }
+  prepend_before(:all) { AddMissingUniqueIndices.down }
+  append_after(:all) do
+    ActsAsTaggableOn::Tag.delete_all
+    AddMissingUniqueIndices.up
+  end
 end
 
 describe ActsAsTaggableOn::Tag do
   before(:each) do
-    clean_database!
     @tag = ActsAsTaggableOn::Tag.new
-    @user = TaggableModel.create(:name => "Pablo")
+    @user = TaggableModel.create(name: 'Pablo')
   end
 
-  describe "named like any" do
-    context "case insensitive collation and unique index on tag name" do
-      if described_class.using_case_insensitive_collation?
+
+  describe 'named like any' do
+    if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
+      context 'case insensitive collation and unique index on tag name' do
         before(:each) do
-          ActsAsTaggableOn::Tag.create(:name => "Awesome")
-          ActsAsTaggableOn::Tag.create(:name => "epic")
+          ActsAsTaggableOn::Tag.create(name: 'Awesome')
+          ActsAsTaggableOn::Tag.create(name: 'epic')
         end
 
-        it "should find both tags" do
-          ActsAsTaggableOn::Tag.named_like_any(["awesome", "epic"]).should have(2).items
+        it 'should find both tags' do
+          expect(ActsAsTaggableOn::Tag.named_like_any(%w(awesome epic)).count).to eq(2)
         end
       end
     end
 
-    context "case insensitive collation without indexes or case sensitive collation with indexes" do
-      if described_class.using_case_insensitive_collation?
+    context 'case insensitive collation without indexes or case sensitive collation with indexes' do
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
         include_context 'without unique index'
       end
 
       before(:each) do
-        ActsAsTaggableOn::Tag.create(:name => "Awesome")
-        ActsAsTaggableOn::Tag.create(:name => "awesome")
-        ActsAsTaggableOn::Tag.create(:name => "epic")
+        ActsAsTaggableOn::Tag.create(name: 'Awesome')
+        ActsAsTaggableOn::Tag.create(name: 'awesome')
+        ActsAsTaggableOn::Tag.create(name: 'epic')
       end
 
-      it "should find both tags" do
-        ActsAsTaggableOn::Tag.named_like_any(["awesome", "epic"]).should have(3).items
+      it 'should find both tags' do
+        expect(ActsAsTaggableOn::Tag.named_like_any(%w(awesome epic)).count).to eq(3)
       end
     end
   end
 
-  describe "find or create by name" do
+  describe 'find or create by name' do
     before(:each) do
-      @tag.name = "awesome"
+      @tag.name = 'awesome'
       @tag.save
     end
 
-    it "should find by name" do
-      ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("awesome").should == @tag
+    it 'should find by name' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('awesome')).to eq(@tag)
     end
 
-    it "should find by name case insensitive" do
-      ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("AWESOME").should == @tag
+    it 'should find by name case insensitive' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('AWESOME')).to eq(@tag)
     end
 
-    it "should create by name" do
-      lambda {
-        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("epic")
-      }.should change(ActsAsTaggableOn::Tag, :count).by(1)
+    it 'should create by name' do
+      expect(-> {
+        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('epic')
+      }).to change(ActsAsTaggableOn::Tag, :count).by(1)
     end
   end
 
-  unless ActsAsTaggableOn::Tag.using_sqlite?
-    describe "find or create by unicode name" do
+  unless ActsAsTaggableOn::Utils.using_sqlite?
+    describe 'find or create by unicode name' do
       before(:each) do
-        @tag.name = "привет"
+        @tag.name = 'привет'
         @tag.save
       end
 
-      it "should find by name" do
-        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("привет").should == @tag
+      it 'should find by name' do
+        expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('привет')).to eq(@tag)
+      end
+
+      it 'should find by name case insensitive' do
+        expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('ПРИВЕТ')).to eq(@tag)
       end
 
-      it "should find by name case insensitive" do
-        ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("ПРИВЕТ").should == @tag
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
+        it 'should find by name accent insensitive' do
+          @tag.name = 'inupiat'
+          @tag.save
+          expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('Iñupiat')).to eq(@tag)
+        end
       end
     end
   end
 
-  describe "find or create all by any name" do
+  describe 'find or create all by any name' do
     before(:each) do
-      @tag.name = "awesome"
+      @tag.name = 'awesome'
       @tag.save
     end
 
-    it "should find by name" do
-      ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("awesome").should == [@tag]
+    it 'should find by name' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('awesome')).to eq([@tag])
     end
 
-    it "should find by name case insensitive" do
-      ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
+    it 'should find by name case insensitive' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('AWESOME')).to eq([@tag])
     end
 
-    context "case sensitive" do
-      if described_class.using_case_insensitive_collation?
+    context 'case sensitive' do
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
         include_context 'without unique index'
       end
 
-      it "should find by name case sensitive" do
+      it 'should find by name case sensitive' do
         ActsAsTaggableOn.strict_case_match = true
         expect {
-          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME")
+          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('AWESOME')
         }.to change(ActsAsTaggableOn::Tag, :count).by(1)
       end
     end
 
-    it "should create by name" do
+    it 'should create by name' do
       expect {
-        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("epic")
+        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('epic')
       }.to change(ActsAsTaggableOn::Tag, :count).by(1)
     end
 
-    context "case sensitive" do
-      if described_class.using_case_insensitive_collation?
+    context 'case sensitive' do
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
         include_context 'without unique index'
       end
 
-      it "should find or create by name case sensitive" do
+      it 'should find or create by name case sensitive' do
         ActsAsTaggableOn.strict_case_match = true
         expect {
-          ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("AWESOME", 'awesome').map(&:name).should == ["AWESOME", "awesome"]
+          expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('AWESOME', 'awesome').map(&:name)).to eq(%w(AWESOME awesome))
         }.to change(ActsAsTaggableOn::Tag, :count).by(1)
       end
     end
 
-    it "should find or create by name" do
+    it 'should find or create by name' do
       expect {
-        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
+        expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('awesome', 'epic').map(&:name)).to eq(%w(awesome epic))
       }.to change(ActsAsTaggableOn::Tag, :count).by(1)
     end
 
-    it "should return an empty array if no tags are specified" do
-      ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name([]).should == []
+    it 'should return an empty array if no tags are specified' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name([])).to be_empty
     end
   end
 
-  it "should require a name" do
+  it 'should require a name' do
     @tag.valid?
+    #TODO, we should find another way to check this
+    expect(@tag.errors[:name]).to eq(["can't be blank"])
 
-    @tag.errors[:name].should == ["can't be blank"]
-
-    @tag.name = "something"
+    @tag.name = 'something'
     @tag.valid?
 
-    @tag.errors[:name].should == []
+    expect(@tag.errors[:name]).to be_empty
   end
 
-  it "should limit the name length to 255 or less characters" do
-    @tag.name = "fgkgnkkgjymkypbuozmwwghblmzpqfsgjasflblywhgkwndnkzeifalfcpeaeqychjuuowlacmuidnnrkprgpcpybarbkrmziqihcrxirlokhnzfvmtzixgvhlxzncyywficpraxfnjptxxhkqmvicbcdcynkjvziefqzyndxkjmsjlvyvbwraklbalykyxoliqdlreeykuphdtmzfdwpphmrqvwvqffojkqhlzvinqajsxbszyvrqqyzusxranr"
+  it 'should limit the name length to 255 or less characters' do
+    @tag.name = 'fgkgnkkgjymkypbuozmwwghblmzpqfsgjasflblywhgkwndnkzeifalfcpeaeqychjuuowlacmuidnnrkprgpcpybarbkrmziqihcrxirlokhnzfvmtzixgvhlxzncyywficpraxfnjptxxhkqmvicbcdcynkjvziefqzyndxkjmsjlvyvbwraklbalykyxoliqdlreeykuphdtmzfdwpphmrqvwvqffojkqhlzvinqajsxbszyvrqqyzusxranr'
     @tag.valid?
-    @tag.errors[:name].should == ["is too long (maximum is 255 characters)"]
+    #TODO, we should find another way to check this
+    expect(@tag.errors[:name]).to eq(['is too long (maximum is 255 characters)'])
 
-    @tag.name = "fgkgnkkgjymkypbuozmwwghblmzpqfsgjasflblywhgkwndnkzeifalfcpeaeqychjuuowlacmuidnnrkprgpcpybarbkrmziqihcrxirlokhnzfvmtzixgvhlxzncyywficpraxfnjptxxhkqmvicbcdcynkjvziefqzyndxkjmsjlvyvbwraklbalykyxoliqdlreeykuphdtmzfdwpphmrqvwvqffojkqhlzvinqajsxbszyvrqqyzusxran"
+    @tag.name = 'fgkgnkkgjymkypbuozmwwghblmzpqfsgjasflblywhgkwndnkzeifalfcpeaeqychjuuowlacmuidnnrkprgpcpybarbkrmziqihcrxirlokhnzfvmtzixgvhlxzncyywficpraxfnjptxxhkqmvicbcdcynkjvziefqzyndxkjmsjlvyvbwraklbalykyxoliqdlreeykuphdtmzfdwpphmrqvwvqffojkqhlzvinqajsxbszyvrqqyzusxran'
     @tag.valid?
-    @tag.errors[:name].should == []
+    expect(@tag.errors[:name]).to be_empty
   end
 
-  it "should equal a tag with the same name" do
-    @tag.name = "awesome"
-    new_tag = ActsAsTaggableOn::Tag.new(:name => "awesome")
-    new_tag.should == @tag
+  it 'should equal a tag with the same name' do
+    @tag.name = 'awesome'
+    new_tag = ActsAsTaggableOn::Tag.new(name: 'awesome')
+    expect(new_tag).to eq(@tag)
   end
 
-  it "should return its name when to_s is called" do
-    @tag.name = "cool"
-    @tag.to_s.should == "cool"
+  it 'should return its name when to_s is called' do
+    @tag.name = 'cool'
+    expect(@tag.to_s).to eq('cool')
   end
 
-  it "have named_scope named(something)" do
-    @tag.name = "cool"
+  it 'have named_scope named(something)' do
+    @tag.name = 'cool'
     @tag.save!
-    ActsAsTaggableOn::Tag.named('cool').should include(@tag)
+    expect(ActsAsTaggableOn::Tag.named('cool')).to include(@tag)
   end
 
-  it "have named_scope named_like(something)" do
-    @tag.name = "cool"
+  it 'have named_scope named_like(something)' do
+    @tag.name = 'cool'
     @tag.save!
-    @another_tag = ActsAsTaggableOn::Tag.create!(:name => "coolip")
-    ActsAsTaggableOn::Tag.named_like('cool').should include(@tag, @another_tag)
+    @another_tag = ActsAsTaggableOn::Tag.create!(name: 'coolip')
+    expect(ActsAsTaggableOn::Tag.named_like('cool')).to include(@tag, @another_tag)
   end
 
-  describe "escape wildcard symbols in like requests" do
+  describe 'escape wildcard symbols in like requests' do
     before(:each) do
-      @tag.name = "cool"
+      @tag.name = 'cool'
       @tag.save
-      @another_tag = ActsAsTaggableOn::Tag.create!(:name => "coo%")
-      @another_tag2 = ActsAsTaggableOn::Tag.create!(:name => "coolish")
+      @another_tag = ActsAsTaggableOn::Tag.create!(name: 'coo%')
+      @another_tag2 = ActsAsTaggableOn::Tag.create!(name: 'coolish')
     end
 
     it "return escaped result when '%' char present in tag" do
-        ActsAsTaggableOn::Tag.named_like('coo%').should_not include(@tag)
-        ActsAsTaggableOn::Tag.named_like('coo%').should include(@another_tag)
+      expect(ActsAsTaggableOn::Tag.named_like('coo%')).to_not include(@tag)
+      expect(ActsAsTaggableOn::Tag.named_like('coo%')).to include(@another_tag)
     end
 
   end
 
-  describe "when using strict_case_match" do
+  describe 'when using strict_case_match' do
     before do
       ActsAsTaggableOn.strict_case_match = true
-      @tag.name = "awesome"
+      @tag.name = 'awesome'
       @tag.save!
     end
 
@@ -211,71 +223,72 @@ describe ActsAsTaggableOn::Tag do
       ActsAsTaggableOn.strict_case_match = false
     end
 
-    it "should find by name" do
-      ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("awesome").should == @tag
+    it 'should find by name' do
+      expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('awesome')).to eq(@tag)
     end
 
-    context "case sensitive" do
-      if described_class.using_case_insensitive_collation?
+    context 'case sensitive' do
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
         include_context 'without unique index'
       end
 
-      it "should find by name case sensitively" do
+      it 'should find by name case sensitively' do
         expect {
-          ActsAsTaggableOn::Tag.find_or_create_with_like_by_name("AWESOME")
+          ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('AWESOME')
         }.to change(ActsAsTaggableOn::Tag, :count)
 
-        ActsAsTaggableOn::Tag.last.name.should == "AWESOME"
+        expect(ActsAsTaggableOn::Tag.last.name).to eq('AWESOME')
       end
     end
 
-    context "case sensitive" do
-      if described_class.using_case_insensitive_collation?
+    context 'case sensitive' do
+      if ActsAsTaggableOn::Utils.using_case_insensitive_collation?
         include_context 'without unique index'
       end
 
-      it "should have a named_scope named(something) that matches exactly" do
-        uppercase_tag = ActsAsTaggableOn::Tag.create(:name => "Cool")
-        @tag.name     = "cool"
+      it 'should have a named_scope named(something) that matches exactly' do
+        uppercase_tag = ActsAsTaggableOn::Tag.create(name: 'Cool')
+        @tag.name = 'cool'
         @tag.save!
 
-        ActsAsTaggableOn::Tag.named('cool').should include(@tag)
-        ActsAsTaggableOn::Tag.named('cool').should_not include(uppercase_tag)
+        expect(ActsAsTaggableOn::Tag.named('cool')).to include(@tag)
+        expect(ActsAsTaggableOn::Tag.named('cool')).to_not include(uppercase_tag)
       end
     end
 
-    it "should not change enconding" do
+    it 'should not change enconding' do
       name = "\u3042"
       original_encoding = name.encoding
-      ActsAsTaggableOn::Tag.find_or_create_with_like_by_name(name)
-      name.encoding.should == original_encoding
+      record = ActsAsTaggableOn::Tag.find_or_create_with_like_by_name(name)
+      record.reload
+      expect(record.name.encoding).to eq(original_encoding)
     end
   end
 
-  describe "name uniqeness validation" do
-    let(:duplicate_tag) { ActsAsTaggableOn::Tag.new(:name => 'ror') }
+  describe 'name uniqeness validation' do
+    let(:duplicate_tag) { ActsAsTaggableOn::Tag.new(name: 'ror') }
 
-    before { ActsAsTaggableOn::Tag.create(:name => 'ror') }
+    before { ActsAsTaggableOn::Tag.create(name: 'ror') }
 
     context "when don't need unique names" do
       include_context 'without unique index'
-      it "should not run uniqueness validation" do
-        duplicate_tag.stub(:validates_name_uniqueness?).and_return(false)
+      it 'should not run uniqueness validation' do
+        allow(duplicate_tag).to receive(:validates_name_uniqueness?) { false }
         duplicate_tag.save
-        duplicate_tag.should be_persisted
+        expect(duplicate_tag).to be_persisted
       end
     end
 
-    context "when do need unique names" do
-      it "should run uniqueness validation" do
-        duplicate_tag.should_not be_valid
+    context 'when do need unique names' do
+      it 'should run uniqueness validation' do
+        expect(duplicate_tag).to_not be_valid
       end
 
-      it "add error to name" do
+      it 'add error to name' do
         duplicate_tag.save
 
-        duplicate_tag.should have(1).errors
-        duplicate_tag.errors.messages[:name].should include('has already been taken')
+        expect(duplicate_tag.errors.size).to eq(1)
+        expect(duplicate_tag.errors.messages[:name]).to include('has already been taken')
       end
     end
   end