sb-acts-as-taggable-on 6.5.0

data/spec/acts_as_taggable_on/single_table_inheritance_spec.rb

@@ -0,0 +1,231 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'Single Table Inheritance' do
+  let(:taggable) { TaggableModel.new(name: 'taggable model') }
+
+  let(:inheriting_model) { InheritingTaggableModel.new(name: 'Inheriting Taggable Model') }
+  let(:altered_inheriting) { AlteredInheritingTaggableModel.new(name: 'Altered Inheriting Model') }
+
+  1.upto(4) do |n|
+    let(:"inheriting_#{n}") { InheritingTaggableModel.new(name: "Inheriting Model #{n}") }
+  end
+
+  let(:student) { Student.create! }
+
+  describe 'tag contexts' do
+    it 'should pass on to STI-inherited models' do
+      expect(inheriting_model).to respond_to(:tag_list, :skill_list, :language_list)
+      expect(altered_inheriting).to respond_to(:tag_list, :skill_list, :language_list)
+    end
+
+    it 'should pass on to altered STI models' do
+      expect(altered_inheriting).to respond_to(:part_list)
+    end
+  end
+
+  context 'matching contexts' do
+
+    before do
+      inheriting_1.offering_list = 'one, two'
+      inheriting_1.need_list = 'one, two'
+      inheriting_1.save!
+
+      inheriting_2.need_list = 'one, two'
+      inheriting_2.save!
+
+      inheriting_3.offering_list = 'one, two'
+      inheriting_3.save!
+
+      inheriting_4.tag_list = 'one, two, three, four'
+      inheriting_4.save!
+
+      taggable.need_list = 'one, two'
+      taggable.save!
+    end
+
+    it 'should find objects with tags of matching contexts' do
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to include(inheriting_2)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_3)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_4)
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(taggable)
+
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(inheriting_2)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_3)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_4)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to include(taggable)
+    end
+
+    it 'should not include the object itself in the list of related objects with tags of matching contexts' do
+      expect(inheriting_1.find_matching_contexts(:offerings, :needs)).to_not include(inheriting_1)
+      expect(inheriting_1.find_matching_contexts_for(InheritingTaggableModel, :offerings, :needs)).to_not include(inheriting_1)
+      expect(inheriting_1.find_matching_contexts_for(TaggableModel, :offerings, :needs)).to_not include(inheriting_1)
+    end
+  end
+
+  context 'find related tags' do
+    before do
+      inheriting_1.tag_list = 'one, two'
+      inheriting_1.save
+
+      inheriting_2.tag_list = 'three, four'
+      inheriting_2.save
+
+      inheriting_3.tag_list = 'one, four'
+      inheriting_3.save
+
+      taggable.tag_list = 'one, two, three, four'
+      taggable.save
+    end
+
+    it 'should find related objects based on tag names on context' do
+      expect(inheriting_1.find_related_tags).to include(inheriting_3)
+      expect(inheriting_1.find_related_tags).to_not include(inheriting_2)
+      expect(inheriting_1.find_related_tags).to_not include(taggable)
+
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(inheriting_3)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_2)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to include(taggable)
+    end
+
+    it 'should not include the object itself in the list of related objects' do
+      expect(inheriting_1.find_related_tags).to_not include(inheriting_1)
+      expect(inheriting_1.find_related_tags_for(InheritingTaggableModel)).to_not include(inheriting_1)
+      expect(inheriting_1.find_related_tags_for(TaggableModel)).to_not include(inheriting_1)
+    end
+  end
+
+  describe 'tag list' do
+    before do
+      @inherited_same = InheritingTaggableModel.new(name: 'inherited same')
+      @inherited_different = AlteredInheritingTaggableModel.new(name: 'inherited different')
+    end
+
+    #TODO, shared example
+    it 'should be able to save tags for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
+      inheriting_model.save
+      expect(InheritingTaggableModel.tagged_with('bob').first).to eq(inheriting_model)
+    end
+
+    it 'should find STI tagged models on the superclass' do
+      inheriting_model.tag_list = 'bob, kelso'
+      inheriting_model.save
+      expect(TaggableModel.tagged_with('bob').first).to eq(inheriting_model)
+    end
+
+    it 'should be able to add on contexts only to some subclasses' do
+      altered_inheriting.part_list = 'fork, spoon'
+      altered_inheriting.save
+      expect(InheritingTaggableModel.tagged_with('fork', on: :parts)).to be_empty
+      expect(AlteredInheritingTaggableModel.tagged_with('fork', on: :parts).first).to eq(altered_inheriting)
+    end
+
+    it 'should have different tag_counts_on for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
+      inheriting_model.save!
+      altered_inheriting.tag_list = 'fork, spoon'
+      altered_inheriting.save!
+
+      expect(InheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tag_counts_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
+    end
+
+    it 'should have different tags_on for inherited models' do
+      inheriting_model.tag_list = 'bob, kelso'
+      inheriting_model.save!
+      altered_inheriting.tag_list = 'fork, spoon'
+      altered_inheriting.save!
+
+      expect(InheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso))
+      expect(AlteredInheritingTaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(fork spoon))
+      expect(TaggableModel.tags_on(:tags, order: "#{ActsAsTaggableOn.tags_table}.id").map(&:name)).to eq(%w(bob kelso fork spoon))
+    end
+
+    it 'should store same tag without validation conflict' do
+      taggable.tag_list = 'one'
+      taggable.save!
+
+      inheriting_model.tag_list = 'one'
+      inheriting_model.save!
+
+      inheriting_model.update! name: 'foo'
+    end
+
+    it "should only join with taggable's table to check type for inherited models" do
+      expect(TaggableModel.tag_counts_on(:tags).to_sql).to_not match /INNER JOIN taggable_models ON/
+      expect(InheritingTaggableModel.tag_counts_on(:tags).to_sql).to match /INNER JOIN taggable_models ON/
+    end
+  end
+
+  describe 'ownership' do
+    it 'should have taggings' do
+      student.tag(taggable, with: 'ruby,scheme', on: :tags)
+      expect(student.owned_taggings.count).to eq(2)
+    end
+
+    it 'should have tags' do
+      student.tag(taggable, with: 'ruby,scheme', on: :tags)
+      expect(student.owned_tags.count).to eq(2)
+    end
+
+    it 'should return tags for the inheriting tagger' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(taggable.tags_from(student)).to eq(%w(ruby scheme))
+    end
+
+    it 'returns all owner tags on the taggable' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      student.tag(taggable, with: 'skill_one', on: :skills)
+      student.tag(taggable, with: 'english, spanish', on: :language)
+      expect(taggable.owner_tags(student).count).to eq(5)
+      expect(taggable.owner_tags(student).sort == %w(english ruby scheme skill_one spanish))
+    end
+
+
+    it 'returns owner tags on the tagger' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(taggable.owner_tags_on(student, :tags).count).to eq(2)
+    end
+
+    it 'returns owner tags on the taggable for an array of contexts' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      student.tag(taggable, with: 'skill_one, skill_two', on: :skills)
+      expect(taggable.owner_tags_on(student, [:tags, :skills]).count).to eq(4)
+      expect(taggable.owner_tags_on(student, [:tags, :skills]).sort == %w(ruby scheme skill_one skill_two))
+    end
+
+    it 'should scope objects returned by tagged_with by owners' do
+      student.tag(taggable, with: 'ruby, scheme', on: :tags)
+      expect(TaggableModel.tagged_with(%w(ruby scheme), owned_by: student).count).to eq(1)
+    end
+  end
+
+  describe 'a subclass of Tag' do
+    let(:company) { Company.new(:name => 'Dewey, Cheatham & Howe') }
+    let(:user) { User.create! }
+
+    subject { Market.create! :name => 'finance' }
+
+    its(:type) { should eql 'Market' }
+
+    it 'sets STI type through string list' do
+      company.market_list = 'law, accounting'
+      company.save!
+      expect(Market.count).to eq(2)
+    end
+
+    it 'does not interfere with a normal Tag context on the same model' do
+      company.location_list = 'cambridge'
+      company.save!
+      expect(ActsAsTaggableOn::Tag.where(name: 'cambridge', type: nil)).to_not be_empty
+    end
+
+    it 'is returned with proper type through ownership' do
+      user.tag(company, :with => 'ripoffs, rackets', :on => :markets)
+      tags = company.owner_tags_on(user, :markets)
+      expect(tags.all? { |tag| tag.is_a? Market }).to be_truthy
+    end
+  end
+end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -0,0 +1,176 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+
+describe ActsAsTaggableOn::TagList do
+  let(:tag_list) { ActsAsTaggableOn::TagList.new('awesome', 'radical') }
+  let(:another_tag_list) { ActsAsTaggableOn::TagList.new('awesome','crazy', 'alien') }
+
+  it { should be_kind_of Array }
+
+
+
+  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)
+      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)
+      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)
+      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(%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')
+      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')
+      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)
+      expect(tag_list).to be_empty
+    end
+
+    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 '#+' 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 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
+
+    context 'without duplicates' do
+      let(:arr) { ['crazy', 'alien'] }
+      let(:another_tag_list) { ActsAsTaggableOn::TagList.new(*arr) }
+      it 'adds other list' do
+        expect(tag_list.concat(another_tag_list)).to eq(%w[awesome radical crazy alien])
+      end
+
+      it 'adds other array' do
+        expect(tag_list.concat(arr)).to eq(%w[awesome radical crazy alien])
+      end
+    end
+  end
+
+  describe '#to_s' do
+    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
+      expect(-> { tag_list.add('cool', 'rad,bodacious') }).to raise_error(RuntimeError)
+      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
+      ActsAsTaggableOn.force_parameterize = true
+      tag_list = ActsAsTaggableOn::TagList.new('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
+      ActsAsTaggableOn.force_lowercase = true
+
+      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
+
+    it 'should ignore case when removing duplicates if strict_case_match is false' do
+      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
+
+      expect(tag_list.to_s).to eq('Junglist, Massive')
+    end
+
+    it 'should not ignore case when removing duplicates if strict_case_match is true' do
+      ActsAsTaggableOn.strict_case_match = true
+      tag_list = ActsAsTaggableOn::TagList.new('Junglist', 'JUNGLIST', 'Junglist', 'Massive', 'MASSIVE', 'MASSIVE')
+
+      expect(tag_list.to_s).to eq('Junglist, JUNGLIST, Massive, MASSIVE')
+      ActsAsTaggableOn.strict_case_match = false
+    end
+  end
+
+  describe 'custom parser' do
+    let(:parser)       { double(parse: %w(cool wicked)) }
+    let(:parser_class) { stub_const('MyParser', Class) }
+
+    it 'should use a the default parser if none is set as parameter' do
+      allow(ActsAsTaggableOn.default_parser).to receive(:new).and_return(parser)
+      ActsAsTaggableOn::TagList.new('cool, wicked', parse: true)
+
+      expect(parser).to have_received(:parse)
+    end
+
+    it 'should use the custom parser passed as parameter' do
+      allow(parser_class).to receive(:new).and_return(parser)
+
+      ActsAsTaggableOn::TagList.new('cool, wicked', parser: parser_class)
+
+      expect(parser).to have_received(:parse)
+    end
+
+    it 'should use the parser setted as attribute' do
+      allow(parser_class).to receive(:new).with('new, tag').and_return(parser)
+
+      tag_list = ActsAsTaggableOn::TagList.new('example')
+      tag_list.parser = parser_class
+      tag_list.add('new, tag', parse: true)
+
+      expect(parser).to have_received(:parse)
+    end
+  end
+
+
+end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -0,0 +1,340 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'db/migrate/2_add_missing_unique_indices.rb'
+
+
+shared_examples_for 'without unique index' do
+  prepend_before(:all) { AddMissingUniqueIndices.down }
+  append_after(:all) do
+    ActsAsTaggableOn::Tag.delete_all
+    AddMissingUniqueIndices.up
+  end
+end
+
+describe ActsAsTaggableOn::Tag do
+  before(:each) do
+    @tag = ActsAsTaggableOn::Tag.new
+    @user = TaggableModel.create(name: 'Pablo')
+  end
+
+
+  describe 'named like any' do
+    context 'case insensitive collation and unique index on tag name', if: using_case_insensitive_collation? do
+      before(:each) do
+        ActsAsTaggableOn::Tag.create(name: 'Awesome')
+        ActsAsTaggableOn::Tag.create(name: 'epic')
+      end
+
+      it 'should find both tags' do
+        expect(ActsAsTaggableOn::Tag.named_like_any(%w(awesome epic)).count).to eq(2)
+      end
+    end
+
+    context 'case insensitive collation without indexes or case sensitive collation with indexes' do
+      if 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')
+      end
+
+      it 'should find both tags' do
+        expect(ActsAsTaggableOn::Tag.named_like_any(%w(awesome epic)).count).to eq(3)
+      end
+    end
+  end
+
+  describe 'named any' do
+    context 'with some special characters combinations', if: using_mysql? do
+      it 'should not raise an invalid encoding exception' do
+        expect{ActsAsTaggableOn::Tag.named_any(["holä", "hol'ä"])}.not_to raise_error
+      end
+    end
+  end
+
+  describe 'for context' do
+    before(:each) do
+      @user.skill_list.add('ruby')
+      @user.save
+    end
+
+    it 'should return tags that have been used in the given context' do
+      expect(ActsAsTaggableOn::Tag.for_context('skills').pluck(:name)).to include('ruby')
+    end
+
+    it 'should not return tags that have been used in other contexts' do
+      expect(ActsAsTaggableOn::Tag.for_context('needs').pluck(:name)).to_not include('ruby')
+    end
+  end
+
+  describe 'find or create by name' do
+    before(:each) do
+      @tag.name = 'awesome'
+      @tag.save
+    end
+
+    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
+      expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('AWESOME')).to eq(@tag)
+    end
+
+    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
+
+  describe 'find or create by unicode name', unless: using_sqlite? do
+    before(:each) do
+      @tag.name = 'привет'
+      @tag.save
+    end
+
+    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 accent insensitive', if: using_case_insensitive_collation? do
+      @tag.name = 'inupiat'
+      @tag.save
+      expect(ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('Iñupiat')).to eq(@tag)
+    end
+  end
+
+  describe 'find or create all by any name' do
+    before(:each) do
+      @tag.name = 'awesome'
+      @tag.save
+    end
+
+    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
+      expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('AWESOME')).to eq([@tag])
+    end
+
+    context 'case sensitive' do
+      if using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      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')
+        }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+      end
+    end
+
+    it 'should create by name' do
+      expect {
+        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name('epic')
+      }.to change(ActsAsTaggableOn::Tag, :count).by(1)
+    end
+
+    context 'case sensitive' do
+      if using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      it 'should find or create by name case sensitive' do
+        ActsAsTaggableOn.strict_case_match = true
+        expect {
+          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
+      expect {
+        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
+      expect(ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name([])).to be_empty
+    end
+  end
+
+  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.name = 'something'
+    @tag.valid?
+
+    expect(@tag.errors[:name]).to be_empty
+  end
+
+  it 'should limit the name length to 255 or less characters' do
+    @tag.name = 'fgkgnkkgjymkypbuozmwwghblmzpqfsgjasflblywhgkwndnkzeifalfcpeaeqychjuuowlacmuidnnrkprgpcpybarbkrmziqihcrxirlokhnzfvmtzixgvhlxzncyywficpraxfnjptxxhkqmvicbcdcynkjvziefqzyndxkjmsjlvyvbwraklbalykyxoliqdlreeykuphdtmzfdwpphmrqvwvqffojkqhlzvinqajsxbszyvrqqyzusxranr'
+    @tag.valid?
+    #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.valid?
+    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')
+    expect(new_tag).to eq(@tag)
+  end
+
+  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'
+    @tag.save!
+    expect(ActsAsTaggableOn::Tag.named('cool')).to include(@tag)
+  end
+
+  it 'have named_scope named_like(something)' do
+    @tag.name = 'cool'
+    @tag.save!
+    @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
+    before(:each) do
+      @tag.name = 'cool'
+      @tag.save
+      @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
+      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
+    before do
+      ActsAsTaggableOn.strict_case_match = true
+      @tag.name = 'awesome'
+      @tag.save!
+    end
+
+    after do
+      ActsAsTaggableOn.strict_case_match = false
+    end
+
+    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 using_case_insensitive_collation?
+        include_context 'without unique index'
+      end
+
+      it 'should find by name case sensitively' do
+        expect {
+          ActsAsTaggableOn::Tag.find_or_create_with_like_by_name('AWESOME')
+        }.to change(ActsAsTaggableOn::Tag, :count)
+
+        expect(ActsAsTaggableOn::Tag.last.name).to eq('AWESOME')
+      end
+    end
+
+    context 'case sensitive' do
+      if 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'
+        @tag.save!
+
+        expect(ActsAsTaggableOn::Tag.named('cool')).to include(@tag)
+        expect(ActsAsTaggableOn::Tag.named('cool')).to_not include(uppercase_tag)
+      end
+    end
+
+    it 'should not change encoding' do
+      name = "\u3042"
+      original_encoding = name.encoding
+      record = ActsAsTaggableOn::Tag.find_or_create_with_like_by_name(name)
+      record.reload
+      expect(record.name.encoding).to eq(original_encoding)
+    end
+
+    context 'named any with some special characters combinations', if: using_mysql? do
+      it 'should not raise an invalid encoding exception' do
+        expect{ActsAsTaggableOn::Tag.named_any(["holä", "hol'ä"])}.not_to raise_error
+      end
+    end
+  end
+
+  describe 'name uniqeness validation' do
+    let(:duplicate_tag) { ActsAsTaggableOn::Tag.new(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
+        allow(duplicate_tag).to receive(:validates_name_uniqueness?) { false }
+        duplicate_tag.save
+        expect(duplicate_tag).to be_persisted
+      end
+    end
+
+    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
+        duplicate_tag.save
+
+        expect(duplicate_tag.errors.size).to eq(1)
+        expect(duplicate_tag.errors.messages[:name]).to include('has already been taken')
+      end
+    end
+  end
+
+  describe 'popular tags' do
+    before do
+      %w(sports rails linux tennis golden_syrup).each_with_index do |t, i|
+        tag = ActsAsTaggableOn::Tag.new(name: t)
+        tag.taggings_count = i
+        tag.save!
+      end
+    end
+
+    it 'should find the most popular tags' do
+      expect(ActsAsTaggableOn::Tag.most_used(3).first.name).to eq("golden_syrup")
+      expect(ActsAsTaggableOn::Tag.most_used(3).length).to eq(3)
+    end
+
+    it 'should find the least popular tags' do
+      expect(ActsAsTaggableOn::Tag.least_used(3).first.name).to eq("sports")
+      expect(ActsAsTaggableOn::Tag.least_used(3).length).to eq(3)
+    end
+  end
+
+end