acts-as-taggable-on 3.1.1 → 3.2.2

data/spec/acts_as_taggable_on/taggable_spec.rb

@@ -1,622 +1,738 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe "Taggable To Preserve Order" do
+describe 'Taggable To Preserve Order' do
   before(:each) do
-    clean_database!
-    @taggable = OrderedTaggableModel.new(:name => "Bob Jones")
+    @taggable = OrderedTaggableModel.new(name: 'Bob Jones')
   end
 
-  it "should have tag types" do
-    [:tags, :colours].each do |type|
-      OrderedTaggableModel.tag_types.should include type
-    end
-
-    @taggable.tag_types.should == OrderedTaggableModel.tag_types
-  end
 
-  it "should have tag associations" do
+  it 'should have tag associations' do
     [:tags, :colours].each do |type|
-      @taggable.respond_to?(type).should be_true
-      @taggable.respond_to?("#{type.to_s.singularize}_taggings").should be_true
+      expect(@taggable.respond_to?(type)).to be_truthy
+      expect(@taggable.respond_to?("#{type.to_s.singularize}_taggings")).to be_truthy
     end
   end
 
-  # it "should have tag associations ordered by id" do
-  #   [:tags, :colours].each do |type|
-  #     OrderedTaggableModel.reflect_on_association(type).options[:order].should include('id')
-  #     OrderedTaggableModel.reflect_on_association("#{type.to_s.singularize}_taggings".to_sym).options[:order].should include('id')
-  #   end
-  # end
-
-  it "should have tag methods" do
+  it 'should have tag methods' do
     [:tags, :colours].each do |type|
-      @taggable.respond_to?("#{type.to_s.singularize}_list").should be_true
-      @taggable.respond_to?("#{type.to_s.singularize}_list=").should be_true
-      @taggable.respond_to?("all_#{type.to_s}_list").should be_true
+      expect(@taggable.respond_to?("#{type.to_s.singularize}_list")).to be_truthy
+      expect(@taggable.respond_to?("#{type.to_s.singularize}_list=")).to be_truthy
+      expect(@taggable.respond_to?("all_#{type}_list")).to be_truthy
     end
   end
 
-  it "should return tag list in the order the tags were created" do
+  it 'should return tag list in the order the tags were created' do
     # create
-    @taggable.tag_list = "rails, ruby, css"
-    @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+    @taggable.tag_list = 'rails, ruby, css'
+    expect(@taggable.instance_variable_get('@tag_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    lambda {
+    expect(-> {
       @taggable.save
-    }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
-    @taggable.tag_list.should == %w(rails ruby css)
+    expect(@taggable.tag_list).to eq(%w(rails ruby css))
 
     # update
-    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.tag_list = 'pow, ruby, rails'
     @taggable.save
 
     @taggable.reload
-    @taggable.tag_list.should == %w(pow ruby rails)
+    expect(@taggable.tag_list).to eq(%w(pow ruby rails))
 
     # update with no change
-    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.tag_list = 'pow, ruby, rails'
     @taggable.save
 
     @taggable.reload
-    @taggable.tag_list.should == %w(pow ruby rails)
+    expect(@taggable.tag_list).to eq(%w(pow ruby rails))
 
     # update to clear tags
-    @taggable.tag_list = ""
+    @taggable.tag_list = ''
     @taggable.save
 
     @taggable.reload
-    @taggable.tag_list.should == []
+    expect(@taggable.tag_list).to be_empty
   end
 
-  it "should return tag objects in the order the tags were created" do
+  it 'should return tag objects in the order the tags were created' do
     # create
-    @taggable.tag_list = "pow, ruby, rails"
-    @taggable.instance_variable_get("@tag_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+    @taggable.tag_list = 'pow, ruby, rails'
+    expect(@taggable.instance_variable_get('@tag_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    lambda {
+    expect(-> {
       @taggable.save
-    }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
-    @taggable.tags.map{|t| t.name}.should == %w(pow ruby rails)
+    expect(@taggable.tags.map { |t| t.name }).to eq(%w(pow ruby rails))
 
     # update
-    @taggable.tag_list = "rails, ruby, css, pow"
+    @taggable.tag_list = 'rails, ruby, css, pow'
     @taggable.save
 
     @taggable.reload
-    @taggable.tags.map{|t| t.name}.should == %w(rails ruby css pow)
+    expect(@taggable.tags.map { |t| t.name }).to eq(%w(rails ruby css pow))
   end
 
-  it "should return tag objects in tagging id order" do
+  it 'should return tag objects in tagging id order' do
     # create
-    @taggable.tag_list = "pow, ruby, rails"
+    @taggable.tag_list = 'pow, ruby, rails'
     @taggable.save
 
     @taggable.reload
-    ids = @taggable.tags.map{|t| t.taggings.first.id}
-    ids.should == ids.sort
+    ids = @taggable.tags.map { |t| t.taggings.first.id }
+    expect(ids).to eq(ids.sort)
 
     # update
-    @taggable.tag_list = "rails, ruby, css, pow"
+    @taggable.tag_list = 'rails, ruby, css, pow'
     @taggable.save
 
     @taggable.reload
-    ids = @taggable.tags.map{|t| t.taggings.first.id}
-    ids.should == ids.sort
+    ids = @taggable.tags.map { |t| t.taggings.first.id }
+    expect(ids).to eq(ids.sort)
   end
 end
 
-describe "Taggable" do
+describe 'Taggable' do
   before(:each) do
-    clean_database!
-    @taggable = TaggableModel.new(:name => "Bob Jones")
-    @taggables = [@taggable, TaggableModel.new(:name => "John Doe")]
+    @taggable = TaggableModel.new(name: 'Bob Jones')
+    @taggables = [@taggable, TaggableModel.new(name: 'John Doe')]
   end
 
-  it "should have tag types" do
+  it 'should have tag types' do
     [:tags, :languages, :skills, :needs, :offerings].each do |type|
-      TaggableModel.tag_types.should include type
+      expect(TaggableModel.tag_types).to include type
     end
 
-    @taggable.tag_types.should == TaggableModel.tag_types
+    expect(@taggable.tag_types).to eq(TaggableModel.tag_types)
   end
 
-  it "should have tag_counts_on" do
-    TaggableModel.tag_counts_on(:tags).should be_empty
+  it 'should have tag_counts_on' do
+    expect(TaggableModel.tag_counts_on(:tags)).to be_empty
 
-    @taggable.tag_list = ["awesome", "epic"]
+    @taggable.tag_list = %w(awesome epic)
     @taggable.save
 
-    TaggableModel.tag_counts_on(:tags).length.should == 2
-    @taggable.tag_counts_on(:tags).length.should == 2
+    expect(TaggableModel.tag_counts_on(:tags).length).to eq(2)
+    expect(@taggable.tag_counts_on(:tags).length).to eq(2)
   end
 
-  it "should have tags_on" do
-    TaggableModel.tags_on(:tags).should be_empty
+  it 'should have tags_on' do
+    expect(TaggableModel.tags_on(:tags)).to be_empty
 
-    @taggable.tag_list = ["awesome", "epic"]
+    @taggable.tag_list = %w(awesome epic)
     @taggable.save
 
-    TaggableModel.tags_on(:tags).length.should == 2
-    @taggable.tags_on(:tags).length.should == 2
+    expect(TaggableModel.tags_on(:tags).length).to eq(2)
+    expect(@taggable.tags_on(:tags).length).to eq(2)
   end
 
-  it "should return [] right after create" do
-    blank_taggable = TaggableModel.new(:name => "Bob Jones")
-    blank_taggable.tag_list.should == []
+  it 'should return [] right after create' do
+    blank_taggable = TaggableModel.new(name: 'Bob Jones')
+    expect(blank_taggable.tag_list).to be_empty
   end
 
-  it "should be able to create tags" do
-    @taggable.skill_list = "ruby, rails, css"
-    @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+  it 'should be able to create tags' do
+    @taggable.skill_list = 'ruby, rails, css'
+    expect(@taggable.instance_variable_get('@skill_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-    lambda {
+    expect(-> {
       @taggable.save
-    }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+    }).to change(ActsAsTaggableOn::Tag, :count).by(3)
 
     @taggable.reload
-    @taggable.skill_list.sort.should == %w(ruby rails css).sort
+    expect(@taggable.skill_list.sort).to eq(%w(ruby rails css).sort)
   end
 
-  it "should be able to create tags through the tag list directly" do
-    @taggable.tag_list_on(:test).add("hello")
-    @taggable.tag_list_cache_on(:test).should_not be_empty
-    @taggable.tag_list_on(:test).should == ["hello"]
+  it 'should be able to create tags through the tag list directly' do
+    @taggable.tag_list_on(:test).add('hello')
+    expect(@taggable.tag_list_cache_on(:test)).to_not be_empty
+    expect(@taggable.tag_list_on(:test)).to eq(['hello'])
 
     @taggable.save
     @taggable.save_tags
 
     @taggable.reload
-    @taggable.tag_list_on(:test).should == ["hello"]
+    expect(@taggable.tag_list_on(:test)).to eq(['hello'])
   end
 
-  it "should differentiate between contexts" do
-    @taggable.skill_list = "ruby, rails, css"
-    @taggable.tag_list = "ruby, bob, charlie"
+  it 'should differentiate between contexts' do
+    @taggable.skill_list = 'ruby, rails, css'
+    @taggable.tag_list = 'ruby, bob, charlie'
     @taggable.save
     @taggable.reload
-    @taggable.skill_list.should include("ruby")
-    @taggable.skill_list.should_not include("bob")
+    expect(@taggable.skill_list).to include('ruby')
+    expect(@taggable.skill_list).to_not include('bob')
   end
 
-  it "should be able to remove tags through list alone" do
-    @taggable.skill_list = "ruby, rails, css"
+  it 'should be able to remove tags through list alone' do
+    @taggable.skill_list = 'ruby, rails, css'
     @taggable.save
     @taggable.reload
-    @taggable.should have(3).skills
-    @taggable.skill_list = "ruby, rails"
+    expect(@taggable.skills.count).to eq(3)
+    @taggable.skill_list = 'ruby, rails'
     @taggable.save
     @taggable.reload
-    @taggable.should have(2).skills
+    expect(@taggable.skills.count).to eq(2)
   end
 
-  it "should be able to select taggables by subset of tags using ActiveRelation methods" do
-    @taggables[0].tag_list = "bob"
-    @taggables[1].tag_list = "charlie"
-    @taggables[0].skill_list = "ruby"
-    @taggables[1].skill_list = "css"
-    @taggables.each{|taggable| taggable.save}
+  it 'should be able to select taggables by subset of tags using ActiveRelation methods' do
+    @taggables[0].tag_list = 'bob'
+    @taggables[1].tag_list = 'charlie'
+    @taggables[0].skill_list = 'ruby'
+    @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(tags: {name: ['bob']})
+    @found_taggables_by_skill = TaggableModel.joins(:skills).where(tags: {name: ['ruby']})
 
-    @found_taggables_by_tag.should include @taggables[0]
-    @found_taggables_by_tag.should_not include @taggables[1]
-    @found_taggables_by_skill.should include @taggables[0]
-    @found_taggables_by_skill.should_not include @taggables[1]
+    expect(@found_taggables_by_tag).to include @taggables[0]
+    expect(@found_taggables_by_tag).to_not include @taggables[1]
+    expect(@found_taggables_by_skill).to include @taggables[0]
+    expect(@found_taggables_by_skill).to_not include @taggables[1]
   end
 
-  it "should be able to find by tag" do
-    @taggable.skill_list = "ruby, rails, css"
+  it 'should be able to find by tag' do
+    @taggable.skill_list = 'ruby, rails, css'
     @taggable.save
 
-    TaggableModel.tagged_with("ruby").first.should == @taggable
+    expect(TaggableModel.tagged_with('ruby').first).to eq(@taggable)
   end
 
-  it "should be able to get a count with find by tag when using a group by" do
-    @taggable.skill_list = "ruby"
+  it 'should be able to get a count with find by tag when using a group by' do
+    @taggable.skill_list = 'ruby'
     @taggable.save
 
-    expect(TaggableModel.tagged_with("ruby").group(:created_at).count.count).to eq(1)
+    expect(TaggableModel.tagged_with('ruby').group(:created_at).count.count).to eq(1)
   end
 
-  it "should be able to find by tag with context" do
-    @taggable.skill_list = "ruby, rails, css"
-    @taggable.tag_list = "bob, charlie"
+  it "shouldn't generate a query with DISTINCT by default" do
+    @taggable.skill_list = 'ruby, rails, css'
     @taggable.save
 
-    TaggableModel.tagged_with("ruby").first.should == @taggable
-    TaggableModel.tagged_with("ruby, css").first.should == @taggable
-    TaggableModel.tagged_with("bob", :on => :skills).first.should_not == @taggable
-    TaggableModel.tagged_with("bob", :on => :tags).first.should == @taggable
+    expect(TaggableModel.tagged_with('ruby').to_sql).to_not match /DISTINCT/
   end
 
-  it "should not care about case" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
+  it 'should be able to find by tag with context' do
+    @taggable.skill_list = 'ruby, rails, css'
+    @taggable.tag_list = 'bob, charlie'
+    @taggable.save
 
-    ActsAsTaggableOn::Tag.all.size.should == 1
-    TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
+    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)
   end
 
-  unless ActsAsTaggableOn::Tag.using_sqlite?
-    it "should not care about case for unicode names" do
+  it 'should not care about case' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby')
+    TaggableModel.create(name: 'Frank', tag_list: 'Ruby')
+
+    expect(ActsAsTaggableOn::Tag.all.size).to eq(1)
+    expect(TaggableModel.tagged_with('ruby').to_a).to eq(TaggableModel.tagged_with('Ruby').to_a)
+  end
+
+  it 'should be able to find by tags with other joins in the query' do
+    @taggable.skill_list = 'ruby, rails, css'
+    @taggable.tag_list = 'bob, charlie'
+    @taggable.save
+
+    expect(TaggableModel.group(:created_at).tagged_with(['bob', 'css'], :any => true).first).to eq(@taggable)
+
+    bob = TaggableModel.create(:name => 'Bob', :tag_list => 'ruby, rails, css')
+    frank = TaggableModel.create(:name => 'Frank', :tag_list => 'ruby, rails')
+    charlie = TaggableModel.create(:name => 'Charlie', :skill_list => 'ruby, java')
+
+    # Test for explicit distinct in select
+    bob.untaggable_models.create!
+    frank.untaggable_models.create!
+    charlie.untaggable_models.create!
+
+    expect(TaggableModel.select('distinct(taggable_models.id), taggable_models.*').joins(:untaggable_models).tagged_with(['css', 'java'], :any => true).to_a.sort).to eq([bob, charlie].sort)
+
+    expect(TaggableModel.select('distinct(taggable_models.id), taggable_models.*').joins(:untaggable_models).tagged_with(['rails', 'ruby'], :any => false).to_a.sort).to eq([bob, frank].sort)
+  end
+
+  unless ActsAsTaggableOn::Utils.using_sqlite?
+    it 'should not care about case for unicode names' do
       ActsAsTaggableOn.strict_case_match = false
-  
-      anya = TaggableModel.create(:name => "Anya", :tag_list => "ПРИВЕТ")
-      igor = TaggableModel.create(:name => "Igor", :tag_list => "привет")
-      katia = TaggableModel.create(:name => "Katia", :tag_list => "ПРИВЕТ")
+      TaggableModel.create(name: 'Anya', tag_list: 'ПРИВЕТ')
+      TaggableModel.create(name: 'Igor', tag_list: 'привет')
+      TaggableModel.create(name: 'Katia', tag_list: 'ПРИВЕТ')
 
-      ActsAsTaggableOn::Tag.all.size.should == 1
-      TaggableModel.tagged_with("привет").to_a.should == TaggableModel.tagged_with("ПРИВЕТ").to_a
+      expect(ActsAsTaggableOn::Tag.all.size).to eq(1)
+      expect(TaggableModel.tagged_with('привет').to_a).to eq(TaggableModel.tagged_with('ПРИВЕТ').to_a)
     end
   end
 
-  it "should be able to create and find tags in languages without capitalization" do
+  context 'should be able to create and find tags in languages without capitalization :' do
     ActsAsTaggableOn.strict_case_match = false
-    chihiro = TaggableModel.create(:name => "Chihiro", :tag_list => "日本の")
-    salim = TaggableModel.create(:name => "Salim", :tag_list => "עברית")
-    ieie = TaggableModel.create(:name => "Ieie", :tag_list => "中国的")
-    yasser = TaggableModel.create(:name => "Yasser", :tag_list => "العربية")
-    emo = TaggableModel.create(:name => "Emo", :tag_list => "✏")
-
-    TaggableModel.tagged_with("日本の").to_a.size.should == 1
-    TaggableModel.tagged_with("עברית").to_a.size.should == 1
-    TaggableModel.tagged_with("中国的").to_a.size.should == 1
-    TaggableModel.tagged_with("العربية").to_a.size.should == 1
-    TaggableModel.tagged_with("✏").to_a.size.should == 1
-  end 
+    {
+        japanese: {name: 'Chihiro', tag_list: '日本の'},
+        hebrew: {name: 'Salim', tag_list: 'עברית'},
+        chinese: {name: 'Ieie', tag_list: '中国的'},
+        arabic: {name: 'Yasser', tag_list: 'العربية'},
+        emo: {name: 'Emo', tag_list: '✏'}
+    }.each do |language, values|
+
+      it language do
+        TaggableModel.create(values)
+        expect(TaggableModel.tagged_with(values[:tag_list]).count).to eq(1)
+      end
+    end
+  end
 
-  it "should be able to get tag counts on model as a whole" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
-    TaggableModel.tag_counts.should_not be_empty
-    TaggableModel.skill_counts.should_not be_empty
+  it 'should be able to get tag counts on model as a whole' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
+    expect(TaggableModel.tag_counts).to_not be_empty
+    expect(TaggableModel.skill_counts).to_not be_empty
   end
 
-  it "should be able to get all tag counts on model as whole" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+  it 'should be able to get all tag counts on model as whole' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    TaggableModel.all_tag_counts.should_not be_empty
-    TaggableModel.all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
+    expect(TaggableModel.all_tag_counts).to_not be_empty
+    expect(TaggableModel.all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
   end
 
-  it "should be able to get all tags on model as whole" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+  it 'should be able to get all tags on model as whole' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    TaggableModel.all_tags.should_not be_empty
-    TaggableModel.all_tags(:order => 'tags.id').first.name.should == "ruby"
+    expect(TaggableModel.all_tags).to_not be_empty
+    expect(TaggableModel.all_tags(order: 'tags.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
-    bob   = TaggableModel.create(:name => "Bob",   :need_list => "rails", :offering_list => "c++")
-    frank = TaggableModel.create(:name => "Frank", :need_list => "css",   :offering_list => "css")
-    steve = TaggableModel.create(:name => 'Steve', :need_list => "c++",   :offering_list => "java")
+  it 'should be able to use named scopes to chain tag finds by any tags by context' do
+    bob = TaggableModel.create(name: 'Bob', need_list: 'rails', offering_list: 'c++')
+    TaggableModel.create(name: 'Frank', need_list: 'css', offering_list: 'css')
+    TaggableModel.create(name: 'Steve', need_list: 'c++', offering_list: 'java')
 
     # Let's only find those who need rails or css and are offering c++ or java
-    TaggableModel.tagged_with(['rails, css'], :on => :needs, :any => true).tagged_with(['c++', 'java'], :on => :offerings, :any => true).to_a.should == [bob]
+    expect(TaggableModel.tagged_with(['rails, css'], on: :needs, any: true).tagged_with(['c++', 'java'], on: :offerings, any: true).to_a).to eq([bob])
   end
 
-  it "should not return read-only records" do
-    TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    TaggableModel.tagged_with("ruby").first.should_not be_readonly
+  it 'should not return read-only records' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    expect(TaggableModel.tagged_with('ruby').first).to_not be_readonly
   end
 
-  it "should be able to get scoped tag counts" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+  it 'should be able to get scoped tag counts' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    TaggableModel.tagged_with("ruby").tag_counts(:order => 'tags.id').first.count.should == 2   # ruby
-    TaggableModel.tagged_with("ruby").skill_counts.first.count.should == 1 # ruby
+    expect(TaggableModel.tagged_with('ruby').tag_counts(order: 'tags.id').first.count).to eq(2) # ruby
+    expect(TaggableModel.tagged_with('ruby').skill_counts.first.count).to eq(1) # ruby
   end
 
-  it "should be able to get all scoped tag counts" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+  it 'should be able to get all scoped tag counts' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    TaggableModel.tagged_with("ruby").all_tag_counts(:order => 'tags.id').first.count.should == 3 # ruby
+    expect(TaggableModel.tagged_with('ruby').all_tag_counts(order: 'tags.id').first.count).to eq(3) # ruby
   end
 
-  it "should be able to get all scoped tags" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby")
+  it 'should be able to get all scoped tags' do
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby')
 
-    TaggableModel.tagged_with("ruby").all_tags(:order => 'tags.id').first.name.should == "ruby"
+    expect(TaggableModel.tagged_with('ruby').all_tags(order: 'tags.id').first.name).to eq('ruby')
   end
 
   it 'should only return tag counts for the available scope' do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby, java")
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby, java')
 
-    TaggableModel.tagged_with('rails').all_tag_counts.should have(3).items
-    TaggableModel.tagged_with('rails').all_tag_counts.any? { |tag| tag.name == 'java' }.should be_false
+    expect(TaggableModel.tagged_with('rails').all_tag_counts.size).to eq(3)
+    expect(TaggableModel.tagged_with('rails').all_tag_counts.any? { |tag| tag.name == 'java' }).to be_falsy
 
     # Test specific join syntaxes:
     frank.untaggable_models.create!
-    TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tag_counts.should have(2).items
-    TaggableModel.tagged_with('rails').joins(:untaggable_models => :taggable_model).all_tag_counts.should have(2).items
-    TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tag_counts.should have(2).items
+    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
 
   it 'should only return tags for the available scope' do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "ruby, rails")
-    charlie = TaggableModel.create(:name => "Charlie", :skill_list => "ruby, java")
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'ruby, rails')
+    TaggableModel.create(name: 'Bob', tag_list: 'ruby, rails, css')
+    TaggableModel.create(name: 'Charlie', skill_list: 'ruby, java')
 
-    TaggableModel.tagged_with('rails').all_tags.should have(3).items
-    TaggableModel.tagged_with('rails').all_tags.any? { |tag| tag.name == 'java' }.should be_false
+    expect(TaggableModel.tagged_with('rails').all_tags.count).to eq(3)
+    expect(TaggableModel.tagged_with('rails').all_tags.any? { |tag| tag.name == 'java' }).to be_falsy
 
     # Test specific join syntaxes:
     frank.untaggable_models.create!
-    TaggableModel.tagged_with('rails').joins(:untaggable_models).all_tags.should have(2).items
-    TaggableModel.tagged_with('rails').joins({ :untaggable_models => :taggable_model }).all_tags.should have(2).items
-    TaggableModel.tagged_with('rails').joins([:untaggable_models]).all_tags.should have(2).items
+    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
 
-  it "should be able to set a custom tag context list" do
-    bob = TaggableModel.create(:name => "Bob")
-    bob.set_tag_list_on(:rotors, "spinning, jumping")
-    bob.tag_list_on(:rotors).should == ["spinning","jumping"]
+  it 'should be able to set a custom tag context list' do
+    bob = TaggableModel.create(name: 'Bob')
+    bob.set_tag_list_on(:rotors, 'spinning, jumping')
+    expect(bob.tag_list_on(:rotors)).to eq(%w(spinning jumping))
     bob.save
     bob.reload
-    bob.tags_on(:rotors).should_not be_empty
+    expect(bob.tags_on(:rotors)).to_not be_empty
   end
 
-  it "should be able to find tagged" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+  it 'should be able to find tagged' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: 'fitter, happier, more productive', skill_list: 'ruby, rails, css')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'weaker, depressed, inefficient', skill_list: 'ruby, rails, css')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier, more productive', skill_list: 'c++, java, ruby')
 
-    TaggableModel.tagged_with("ruby", :order => 'taggable_models.name').to_a.should == [bob, frank, steve]
-    TaggableModel.tagged_with("ruby, rails", :order => 'taggable_models.name').to_a.should == [bob, frank]
-    TaggableModel.tagged_with(["ruby", "rails"], :order => 'taggable_models.name').to_a.should == [bob, frank]
+    expect(TaggableModel.tagged_with('ruby', order: 'taggable_models.name').to_a).to eq([bob, frank, steve])
+    expect(TaggableModel.tagged_with('ruby, rails', order: 'taggable_models.name').to_a).to eq([bob, frank])
+    expect(TaggableModel.tagged_with(%w(ruby rails), order: 'taggable_models.name').to_a).to eq([bob, frank])
   end
 
-  it "should be able to find tagged with quotation marks" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive, 'I love the ,comma,'")
-    TaggableModel.tagged_with("'I love the ,comma,'").should include(bob)
+  it 'should be able to find tagged with quotation marks' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: "fitter, happier, more productive, 'I love the ,comma,'")
+    expect(TaggableModel.tagged_with("'I love the ,comma,'")).to include(bob)
   end
 
-  it "should be able to find tagged with invalid tags" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive")
-    TaggableModel.tagged_with("sad, happier").should_not include(bob)
+  it 'should be able to find tagged with invalid tags' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: 'fitter, happier, more productive')
+    expect(TaggableModel.tagged_with('sad, happier')).to_not include(bob)
   end
 
-  it "should be able to find tagged with any tag" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+  it 'should be able to find tagged with any tag' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: 'fitter, happier, more productive', skill_list: 'ruby, rails, css')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'weaker, depressed, inefficient', skill_list: 'ruby, rails, css')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier, more productive', skill_list: 'c++, java, ruby')
 
-    TaggableModel.tagged_with(["ruby", "java"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank, steve]
-    TaggableModel.tagged_with(["c++", "fitter"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, steve]
-    TaggableModel.tagged_with(["depressed", "css"], :order => 'taggable_models.name', :any => true).to_a.should == [bob, frank]
+    expect(TaggableModel.tagged_with(%w(ruby java), order: 'taggable_models.name', any: true).to_a).to eq([bob, frank, steve])
+    expect(TaggableModel.tagged_with(%w(c++ fitter), order: 'taggable_models.name', any: true).to_a).to eq([bob, steve])
+    expect(TaggableModel.tagged_with(%w(depressed css), order: 'taggable_models.name', any: true).to_a).to eq([bob, frank])
   end
 
-  it "should be able to order by number of matching tags when matching any" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+  it 'should be able to order by number of matching tags when matching any' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: 'fitter, happier, more productive', skill_list: 'ruby, rails, css')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'weaker, depressed, inefficient', skill_list: 'ruby, rails, css')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier, more productive', skill_list: 'c++, java, ruby')
 
-    TaggableModel.tagged_with(["ruby", "java"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
-    TaggableModel.tagged_with(["c++", "fitter"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob]
-    TaggableModel.tagged_with(["depressed", "css"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [frank, bob]
-    TaggableModel.tagged_with(["fitter", "happier", "more productive", "c++", "java", "ruby"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
-    TaggableModel.tagged_with(["c++", "java", "ruby", "fitter"], :any => true, :order_by_matching_tag_count => true, :order => 'taggable_models.name').to_a.should == [steve, bob, frank]
+    expect(TaggableModel.tagged_with(%w(ruby java), any: true, order_by_matching_tag_count: true, order: 'taggable_models.name').to_a).to eq([steve, bob, frank])
+    expect(TaggableModel.tagged_with(%w(c++ fitter), any: true, order_by_matching_tag_count: true, order: 'taggable_models.name').to_a).to eq([steve, bob])
+    expect(TaggableModel.tagged_with(%w(depressed css), any: true, order_by_matching_tag_count: true, order: 'taggable_models.name').to_a).to eq([frank, bob])
+    expect(TaggableModel.tagged_with(['fitter', 'happier', 'more productive', 'c++', 'java', 'ruby'], any: true, order_by_matching_tag_count: true, order: 'taggable_models.name').to_a).to eq([steve, bob, frank])
+    expect(TaggableModel.tagged_with(%w(c++ java ruby fitter), any: true, order_by_matching_tag_count: true, order: 'taggable_models.name').to_a).to eq([steve, bob, frank])
   end
 
-  context "wild: true" do
-    it "should use params as wildcards" do
-      bob = TaggableModel.create(:name => "Bob", :tag_list => "bob, tricia")
-      frank = TaggableModel.create(:name => "Frank", :tag_list => "bobby, jim")
-      steve = TaggableModel.create(:name => "Steve", :tag_list => "john, patricia")
-      jim = TaggableModel.create(:name => "Jim", :tag_list => "jim, steve")
-
+  context 'wild: true' do
+    it 'should use params as wildcards' do
+      bob = TaggableModel.create(name: 'Bob', tag_list: 'bob, tricia')
+      frank = TaggableModel.create(name: 'Frank', tag_list: 'bobby, jim')
+      steve = TaggableModel.create(name: 'Steve', tag_list: 'john, patricia')
+      jim = TaggableModel.create(name: 'Jim', tag_list: 'jim, steve')
 
-      TaggableModel.tagged_with(["bob", "tricia"], :wild => true, :any => true).to_a.sort_by{|o| o.id}.should == [bob, frank, steve]
-      TaggableModel.tagged_with(["bob", "tricia"], :wild => true, :exclude => true).to_a.should == [jim]
+      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])
     end
   end
 
-  it "should be able to find tagged on a custom tag context" do
-    bob = TaggableModel.create(:name => "Bob")
-    bob.set_tag_list_on(:rotors, "spinning, jumping")
-    bob.tag_list_on(:rotors).should == ["spinning","jumping"]
+  it 'should be able to find tagged on a custom tag context' do
+    bob = TaggableModel.create(name: 'Bob')
+    bob.set_tag_list_on(:rotors, 'spinning, jumping')
+    expect(bob.tag_list_on(:rotors)).to eq(%w(spinning jumping))
     bob.save
 
-    TaggableModel.tagged_with("spinning", :on => :rotors).to_a.should == [bob]
+    expect(TaggableModel.tagged_with('spinning', on: :rotors).to_a).to eq([bob])
   end
 
-  it "should be able to use named scopes to chain tag finds" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "fitter, happier, more productive", :skill_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "weaker, depressed, inefficient", :skill_list => "ruby, rails, css")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, python')
+  it 'should be able to use named scopes to chain tag finds' do
+    bob = TaggableModel.create(name: 'Bob', tag_list: 'fitter, happier, more productive', skill_list: 'ruby, rails, css')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'weaker, depressed, inefficient', skill_list: 'ruby, rails, css')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier, more productive', skill_list: 'c++, java, python')
 
     # Let's only find those productive Rails developers
-    TaggableModel.tagged_with('rails', :on => :skills, :order => 'taggable_models.name').to_a.should == [bob, frank]
-    TaggableModel.tagged_with('happier', :on => :tags, :order => 'taggable_models.name').to_a.should == [bob, steve]
-    TaggableModel.tagged_with('rails', :on => :skills).tagged_with('happier', :on => :tags).to_a.should == [bob]
-    TaggableModel.tagged_with('rails').tagged_with('happier', :on => :tags).to_a.should == [bob]
+    expect(TaggableModel.tagged_with('rails', on: :skills, order: 'taggable_models.name').to_a).to eq([bob, frank])
+    expect(TaggableModel.tagged_with('happier', on: :tags, order: 'taggable_models.name').to_a).to eq([bob, steve])
+    expect(TaggableModel.tagged_with('rails', on: :skills).tagged_with('happier', on: :tags).to_a).to eq([bob])
+    expect(TaggableModel.tagged_with('rails').tagged_with('happier', on: :tags).to_a).to eq([bob])
   end
 
-  it "should be able to find tagged with only the matching tags" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier")
+  it 'should be able to find tagged with only the matching tags' do
+    TaggableModel.create(name: 'Bob', tag_list: 'lazy, happier')
+    TaggableModel.create(name: 'Frank', tag_list: 'fitter, happier, inefficient')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier')
 
-    TaggableModel.tagged_with("fitter, happier", :match_all => true).to_a.should == [steve]
+    expect(TaggableModel.tagged_with('fitter, happier', match_all: true).to_a).to eq([steve])
   end
 
-  it "should be able to find tagged with only the matching tags for a context" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "lazy, happier", :skill_list => "ruby, rails, css")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "fitter, happier, inefficient", :skill_list => "css")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => "fitter, happier", :skill_list => "ruby, rails, css")
+  it 'should be able to find tagged with only the matching tags for a context' do
+    TaggableModel.create(name: 'Bob', tag_list: 'lazy, happier', skill_list: 'ruby, rails, css')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'fitter, happier, inefficient', skill_list: 'css')
+    TaggableModel.create(name: 'Steve', tag_list: 'fitter, happier', skill_list: 'ruby, rails, css')
 
-    TaggableModel.tagged_with("css", :on => :skills, :match_all => true).to_a.should == [frank]
+    expect(TaggableModel.tagged_with('css', on: :skills, match_all: true).to_a).to eq([frank])
   end
 
-  it "should be able to find tagged with some excluded tags" do
-    bob = TaggableModel.create(:name => "Bob", :tag_list => "happier, lazy")
-    frank = TaggableModel.create(:name => "Frank", :tag_list => "happier")
-    steve = TaggableModel.create(:name => 'Steve', :tag_list => "happier")
+  it 'should be able to find tagged with some excluded tags' do
+    TaggableModel.create(name: 'Bob', tag_list: 'happier, lazy')
+    frank = TaggableModel.create(name: 'Frank', tag_list: 'happier')
+    steve = TaggableModel.create(name: 'Steve', tag_list: 'happier')
 
-    TaggableModel.tagged_with("lazy", :exclude => true).to_a.should == [frank, steve]
+    expect(TaggableModel.tagged_with('lazy', exclude: true)).to include(frank, steve)
+    expect(TaggableModel.tagged_with('lazy', exclude: true).size).to eq(2)
   end
 
-  it "should return an empty scope for empty tags" do
-    TaggableModel.tagged_with('').should == []
-    TaggableModel.tagged_with(' ').should == []
-    TaggableModel.tagged_with(nil).should == []
-    TaggableModel.tagged_with([]).should == []
+  it 'should return an empty scope for empty tags' do
+    ['', ' ', nil, []].each do |tag|
+      expect(TaggableModel.tagged_with(tag)).to be_empty
+    end
   end
 
-  it "should not create duplicate taggings" do
-    bob = TaggableModel.create(:name => "Bob")
-    lambda {
-      bob.tag_list << "happier"
-      bob.tag_list << "happier"
-      bob.save
-    }.should change(ActsAsTaggableOn::Tagging, :count).by(1)
+  context 'Duplicates' do
+    context 'should not create duplicate taggings' do
+      let(:bob) { TaggableModel.create(name: 'Bob') }
+      context 'case sensitive' do
+        it '#add' do
+          expect(lambda {
+            bob.tag_list.add 'happier'
+            bob.tag_list.add 'happier'
+            bob.tag_list.add 'happier', 'rich', 'funny'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(3)
+        end
+        it '#<<' do
+          expect(lambda {
+            bob.tag_list << 'social'
+            bob.tag_list << 'social'
+            bob.tag_list << 'social' << 'wow'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+
+        end
+
+        it 'unicode' do
+
+          expect(lambda {
+            bob.tag_list.add 'ПРИВЕТ'
+            bob.tag_list.add 'ПРИВЕТ'
+            bob.tag_list.add 'ПРИВЕТ', 'ПРИВЕТ'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+
+        end
+
+        it '#=' do
+          expect(lambda {
+            bob.tag_list = ['Happy', 'Happy']
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+        end
+      end
+      context 'case insensitive' do
+        before(:all) { ActsAsTaggableOn.force_lowercase = true }
+        after(:all) { ActsAsTaggableOn.force_lowercase = false }
+
+        it '#<<' do
+          expect(lambda {
+            bob.tag_list << 'Alone'
+            bob.tag_list << 'AloNe'
+            bob.tag_list << 'ALONE' << 'In The dark'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+
+        end
+
+        it '#add' do
+          expect(lambda {
+            bob.tag_list.add 'forever'
+            bob.tag_list.add 'ForEver'
+            bob.tag_list.add 'FOREVER', 'ALONE'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(2)
+        end
+
+        it 'unicode' do
+
+          expect(lambda {
+            bob.tag_list.add 'ПРИВЕТ'
+            bob.tag_list.add 'привет', 'Привет'
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+
+        end
+
+        it '#=' do
+          expect(lambda {
+            bob.tag_list = ['Happy', 'HAPPY']
+            bob.save
+          }).to change(ActsAsTaggableOn::Tagging, :count).by(1)
+        end
+
+
+      end
+
+
+    end
+
+    if ActsAsTaggableOn::Utils.supports_concurrency?
+      xit 'should not duplicate tags added on different threads' do
+        #TODO, try with more threads and fix deadlock
+        thread_count = 4
+        barrier = Barrier.new thread_count
+
+        expect {
+          thread_count.times.map do |idx|
+            Thread.start do
+              connor = TaggableModel.first_or_create(name: 'Connor')
+              connor.tag_list = 'There, can, be, only, one'
+              barrier.wait
+              begin
+                connor.save
+              rescue ActsAsTaggableOn::DuplicateTagError
+                # second save should succeed
+                connor.save
+              end
+            end
+          end.map(&:join)
+        }.to change(ActsAsTaggableOn::Tag, :count).by(5)
+      end
+    end
   end
 
-  describe "Associations" do
+  describe 'Associations' do
     before(:each) do
-      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+      @taggable = TaggableModel.create(tag_list: 'awesome, epic')
     end
 
-    it "should not remove tags when creating associated objects" do
+    it 'should not remove tags when creating associated objects' do
       @taggable.untaggable_models.create!
       @taggable.reload
-      @taggable.tag_list.should have(2).items
+      expect(@taggable.tag_list.size).to eq(2)
     end
   end
 
-  describe "grouped_column_names_for method" do
-    it "should return all column names joined for Tag GROUP clause" do
-      @taggable.grouped_column_names_for(ActsAsTaggableOn::Tag).should == "tags.id, tags.name, tags.taggings_count"
+  describe 'grouped_column_names_for method' do
+    it 'should return all column names joined for Tag GROUP clause' 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')
     end
 
-    it "should return all column names joined for TaggableModel GROUP clause" do
-      @taggable.grouped_column_names_for(TaggableModel).should == "taggable_models.id, taggable_models.name, taggable_models.type"
+    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')
     end
 
-    it "should return all column names joined for NonStandardIdTaggableModel GROUP clause" do
-      @taggable.grouped_column_names_for(TaggableModel).should == "taggable_models.#{TaggableModel.primary_key}, taggable_models.name, taggable_models.type"
+    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")
     end
   end
 
-  describe "NonStandardIdTaggable" do
+  describe 'NonStandardIdTaggable' do
     before(:each) do
-      clean_database!
-      @taggable = NonStandardIdTaggableModel.new(:name => "Bob Jones")
-      @taggables = [@taggable, NonStandardIdTaggableModel.new(:name => "John Doe")]
+      @taggable = NonStandardIdTaggableModel.new(name: 'Bob Jones')
+      @taggables = [@taggable, NonStandardIdTaggableModel.new(name: 'John Doe')]
     end
 
-    it "should have tag types" do
+    it 'should have tag types' do
       [:tags, :languages, :skills, :needs, :offerings].each do |type|
-        NonStandardIdTaggableModel.tag_types.should include type
+        expect(NonStandardIdTaggableModel.tag_types).to include type
       end
 
-      @taggable.tag_types.should == NonStandardIdTaggableModel.tag_types
+      expect(@taggable.tag_types).to eq(NonStandardIdTaggableModel.tag_types)
     end
 
-    it "should have tag_counts_on" do
-      NonStandardIdTaggableModel.tag_counts_on(:tags).should be_empty
+    it 'should have tag_counts_on' do
+      expect(NonStandardIdTaggableModel.tag_counts_on(:tags)).to be_empty
 
-      @taggable.tag_list = ["awesome", "epic"]
+      @taggable.tag_list = %w(awesome epic)
       @taggable.save
 
-      NonStandardIdTaggableModel.tag_counts_on(:tags).length.should == 2
-      @taggable.tag_counts_on(:tags).length.should == 2
+      expect(NonStandardIdTaggableModel.tag_counts_on(:tags).length).to eq(2)
+      expect(@taggable.tag_counts_on(:tags).length).to eq(2)
     end
 
-    it "should have tags_on" do
-      NonStandardIdTaggableModel.tags_on(:tags).should be_empty
+    it 'should have tags_on' do
+      expect(NonStandardIdTaggableModel.tags_on(:tags)).to be_empty
 
-      @taggable.tag_list = ["awesome", "epic"]
+      @taggable.tag_list = %w(awesome epic)
       @taggable.save
 
-      NonStandardIdTaggableModel.tags_on(:tags).length.should == 2
-      @taggable.tags_on(:tags).length.should == 2
+      expect(NonStandardIdTaggableModel.tags_on(:tags).length).to eq(2)
+      expect(@taggable.tags_on(:tags).length).to eq(2)
     end
 
-    it "should be able to create tags" do
-      @taggable.skill_list = "ruby, rails, css"
-      @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::TagList).should be_true
+    it 'should be able to create tags' do
+      @taggable.skill_list = 'ruby, rails, css'
+      expect(@taggable.instance_variable_get('@skill_list').instance_of?(ActsAsTaggableOn::TagList)).to be_truthy
 
-      lambda {
+      expect(-> {
         @taggable.save
-      }.should change(ActsAsTaggableOn::Tag, :count).by(3)
+      }).to change(ActsAsTaggableOn::Tag, :count).by(3)
 
       @taggable.reload
-      @taggable.skill_list.sort.should == %w(ruby rails css).sort
+      expect(@taggable.skill_list.sort).to eq(%w(ruby rails css).sort)
     end
 
-    it "should be able to create tags through the tag list directly" do
-      @taggable.tag_list_on(:test).add("hello")
-      @taggable.tag_list_cache_on(:test).should_not be_empty
-      @taggable.tag_list_on(:test).should == ["hello"]
+    it 'should be able to create tags through the tag list directly' do
+      @taggable.tag_list_on(:test).add('hello')
+      expect(@taggable.tag_list_cache_on(:test)).to_not be_empty
+      expect(@taggable.tag_list_on(:test)).to eq(['hello'])
 
       @taggable.save
       @taggable.save_tags
 
       @taggable.reload
-      @taggable.tag_list_on(:test).should == ["hello"]
+      expect(@taggable.tag_list_on(:test)).to eq(['hello'])
     end
   end
 
-  describe "Dirty Objects" do
-    context "with un-contexted tags" do
+  describe 'Dirty Objects' do
+    context 'with un-contexted tags' do
       before(:each) do
-        @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+        @taggable = TaggableModel.create(tag_list: 'awesome, epic')
       end
 
-      context "when tag_list changed" do
+      context 'when tag_list changed' do
         before(:each) do
-          @taggable.changes.should == {}
+          expect(@taggable.changes).to be_empty
           @taggable.tag_list = 'one'
         end
 
         it 'should show changes of dirty object' do
-          @taggable.changes.should == {"tag_list"=>["awesome, epic", ["one"]]}
+          expect(@taggable.changes).to eq({'tag_list' => ['awesome, epic', ['one']]})
         end
 
         it 'flags tag_list as changed' do
-          @taggable.tag_list_changed?.should be_true
+          expect(@taggable.tag_list_changed?).to be_truthy
         end
 
         it 'preserves original value' do
-          @taggable.tag_list_was.should == "awesome, epic"
+          expect(@taggable.tag_list_was).to eq('awesome, epic')
         end
 
         it 'shows what the change was' do
-          @taggable.tag_list_change.should == ["awesome, epic", ["one"]]
+          expect(@taggable.tag_list_change).to eq(['awesome, epic', ['one']])
         end
       end
 
       context 'when tag_list is the same' do
         before(:each) do
-          @taggable.tag_list = "awesome, epic"
+          @taggable.tag_list = 'awesome, epic'
         end
 
         it 'is not flagged as changed' do
-          @taggable.tag_list_changed?.should be_false
+          expect(@taggable.tag_list_changed?).to be_falsy
         end
 
         it 'does not show any changes to the taggable item' do
-          @taggable.changes.should == {}
+          expect(@taggable.changes).to be_empty
         end
 
         context "and using a delimiter different from a ','" do
@@ -630,64 +746,135 @@ describe "Taggable" do
           end
 
           it 'does not show any changes to the taggable item when using array assignments' do
-            @taggable.tag_list = ["awesome", "epic"]
-            @taggable.changes.should == {}
+            @taggable.tag_list = %w(awesome epic)
+            expect(@taggable.changes).to be_empty
           end
         end
       end
     end
 
-    context "with context tags" do
+    context 'with context tags' do
       before(:each) do
-        @taggable = TaggableModel.create(:language_list => "awesome, epic")
+        @taggable = TaggableModel.create('language_list' => 'awesome, epic')
       end
 
-      context "when language_list changed" do
+      context 'when language_list changed' do
         before(:each) do
-          @taggable.changes.should == {}
+          expect(@taggable.changes).to be_empty
           @taggable.language_list = 'one'
         end
 
         it 'should show changes of dirty object' do
-          @taggable.changes.should == {"language_list"=>["awesome, epic", ["one"]]}
+          expect(@taggable.changes).to eq({'language_list' => ['awesome, epic', ['one']]})
         end
 
         it 'flags language_list as changed' do
-          @taggable.language_list_changed?.should be_true
+          expect(@taggable.language_list_changed?).to be_truthy
         end
 
         it 'preserves original value' do
-          @taggable.language_list_was.should == "awesome, epic"
+          expect(@taggable.language_list_was).to eq('awesome, epic')
         end
 
         it 'shows what the change was' do
-          @taggable.language_list_change.should == ["awesome, epic", ["one"]]
+          expect(@taggable.language_list_change).to eq(['awesome, epic', ['one']])
         end
 
         it 'shows what the changes were' do
-          @taggable.language_list_changes.should == ["awesome, epic", ["one"]]
+          expect(@taggable.language_list_changes).to eq(['awesome, epic', ['one']])
         end
       end
 
       context 'when language_list is the same' do
         before(:each) do
-          @taggable.language_list = "awesome, epic"
+          @taggable.language_list = 'awesome, epic'
         end
 
         it 'is not flagged as changed' do
-          @taggable.language_list_changed?.should be_false
+          expect(@taggable.language_list_changed?).to be_falsy
         end
 
         it 'does not show any changes to the taggable item' do
-          @taggable.changes.should == {}
+          expect(@taggable.changes).to be_empty
+        end
+      end
+    end
+  end
+
+  describe 'Autogenerated methods' do
+    it 'should be overridable' do
+      expect(TaggableModel.create(tag_list: 'woo').tag_list_submethod_called).to be_truthy
+    end
+  end
+
+  # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
+  context 'tag_counts and aggreating scopes, compatability with MySQL ' do
+    before(:each) do
+      TaggableModel.new(:name => 'Barb Jones').tap { |t| t.tag_list = %w(awesome fun) }.save
+      TaggableModel.new(:name => 'John Doe').tap { |t| t.tag_list = %w(cool fun hella) }.save
+      TaggableModel.new(:name => 'Jo Doe').tap { |t| t.tag_list = %w(curious young naive sharp) }.save
+
+      TaggableModel.all.each { |t| t.save }
+    end
+
+    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
+
+    context 'regression prevention, just making sure these esoteric queries still work' do
+      context 'Model.tag_counts.limit(x)' do
+        it 'should limit the tag objects (not very useful, of course)' do
+          array_of_tag_counts = TaggableModel.tag_counts.limit(2)
+          expect(array_of_tag_counts.count).to eq(2)
+        end
+      end
+
+      context 'Model.tag_counts.sum(:tags_count)' do
+        it 'should limit the total tags used' do
+          expect(TaggableModel.tag_counts.sum(:tags_count).to_i).to eq(9)
+        end
+      end
+
+      context 'Model.tag_counts.limit(2).sum(:tags_count)' do
+        it 'limit should have no effect; this is just a sanity check' do
+          expect(TaggableModel.tag_counts.limit(2).sum(:tags_count).to_i).to eq(9)
         end
       end
     end
   end
+end
+
+if ActsAsTaggableOn::Utils.using_postgresql?
+  if ActsAsTaggableOn::Utils.postgresql_support_json?
+    describe 'Taggable model with json columns' do
+      before(:each) do
+        @taggable = TaggableModelWithJson.new(:name => 'Bob Jones')
+        @taggables = [@taggable, TaggableModelWithJson.new(:name => 'John Doe')]
+      end
+
+      it 'should be able to find by tag with context' do
+        @taggable.skill_list = 'ruby, rails, css'
+        @taggable.tag_list = 'bob, charlie'
+        @taggable.save
+
+        expect(TaggableModelWithJson.tagged_with('ruby').first).to eq(@taggable)
+        expect(TaggableModelWithJson.tagged_with('ruby, css').first).to eq(@taggable)
+        expect(TaggableModelWithJson.tagged_with('bob', :on => :skills).first).to_not eq(@taggable)
+        expect(TaggableModelWithJson.tagged_with('bob', :on => :tags).first).to eq(@taggable)
+      end
 
-  describe "Autogenerated methods" do
-    it "should be overridable" do
-      TaggableModel.create(:tag_list=>'woo').tag_list_submethod_called.should be_true
+      it 'should be able to find tagged with any tag' do
+        bob = TaggableModelWithJson.create(:name => 'Bob', :tag_list => 'fitter, happier, more productive', :skill_list => 'ruby, rails, css')
+        frank = TaggableModelWithJson.create(:name => 'Frank', :tag_list => 'weaker, depressed, inefficient', :skill_list => 'ruby, rails, css')
+        steve = TaggableModelWithJson.create(:name => 'Steve', :tag_list => 'fitter, happier, more productive', :skill_list => 'c++, java, ruby')
+
+        expect(TaggableModelWithJson.tagged_with(%w(ruby java), :order => 'taggable_model_with_jsons.name', :any => true).to_a).to eq([bob, frank, steve])
+        expect(TaggableModelWithJson.tagged_with(%w(c++ fitter), :order => 'taggable_model_with_jsons.name', :any => true).to_a).to eq([bob, steve])
+        expect(TaggableModelWithJson.tagged_with(%w(depressed css), :order => 'taggable_model_with_jsons.name', :any => true).to_a).to eq([bob, frank])
+      end
     end
   end
 end