acts-as-taggable-on 2.0.0.pre5 → 3.5.0

data/spec/acts_as_taggable_on/tag_list_parser_spec.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe ActsAsTaggableOn::TagListParser do
+  it '#parse should return empty array if empty array is passed' do
+    expect(ActsAsTaggableOn::TagListParser.parse([])).to be_empty
+  end
+
+  describe 'Multiple Delimiter' do
+    before do
+      @old_delimiter = ActsAsTaggableOn.delimiter
+    end
+
+    after do
+      ActsAsTaggableOn.delimiter = @old_delimiter
+    end
+
+    it 'should separate tags by delimiters' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('cool, data|I have')
+      expect(tag_list.to_s).to eq('cool, data, I, have')
+    end
+
+    it 'should escape quote' do
+      ActsAsTaggableOn.delimiter = [',', ' ', '\|']
+      tag_list = ActsAsTaggableOn::TagListParser.parse "'I have'|cool, data"
+      expect(tag_list.to_s).to eq('"I have", cool, data')
+
+      tag_list = ActsAsTaggableOn::TagListParser.parse '"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
+      ActsAsTaggableOn.delimiter = ['，', '的', '可能是']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('我的东西可能是不见了，还好有备份')
+      expect(tag_list.to_s).to eq('我， 东西， 不见了， 还好有备份')
+    end
+
+    it 'should work for multiple quoted tags' do
+      ActsAsTaggableOn.delimiter = [',']
+      tag_list = ActsAsTaggableOn::TagListParser.parse('"Ruby Monsters","eat Katzenzungen"')
+      expect(tag_list.to_s).to eq('Ruby Monsters, eat Katzenzungen')
+    end
+  end
+
+end

data/spec/acts_as_taggable_on/tag_list_spec.rb

@@ -1,70 +1,150 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+# -*- 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
 
-describe TagList do
-  before(:each) do
-    @tag_list = TagList.new("awesome","radical")
-  end
-  
-  it "should be an array" do
-    @tag_list.is_a?(Array).should be_true
-  end
-  
-  it "should be able to be add a new tag word" do
-    @tag_list.add("cool")
-    @tag_list.include?("cool").should be_true
-  end
-  
-  it "should be able to add delimited lists of words" do
-    @tag_list.add("cool, wicked", :parse => true)
-    @tag_list.include?("cool").should be_true
-    @tag_list.include?("wicked").should be_true
-  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.include?("cool, wicked").should be_true
-    @tag_list.include?("really cool, really wicked").should be_true
-  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.include?("john's cool car").should be_true
-    @tag_list.include?("mary's wicked toy").should be_true
-  end
-  
-  it "should be able to add an array of words" do
-    @tag_list.add(["cool", "wicked"], :parse => true)
-    @tag_list.include?("cool").should be_true
-    @tag_list.include?("wicked").should be_true
   end
-  
-  it "should be able to remove words" do
-    @tag_list.remove("awesome")
-    @tag_list.include?("awesome").should be_false
+
+  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
-  
-  it "should be able to remove delimited lists of words" do
-    @tag_list.remove("awesome, radical", :parse => true)
-    @tag_list.should be_empty
+
+  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
-  
-  it "should be able to remove an array of words" do
-    @tag_list.remove(["awesome", "radical"], :parse => true)
-    @tag_list.should be_empty
+
+  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
-  
-  it "should give a delimited list of words when converted to string" do
-    @tag_list.to_s.should == "awesome, radical"
+
+  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
+      expect(-> { tag_list.to_s }).to_not raise_error
+    end
   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\""
+
+  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
   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
+
+  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
+
+
+end

data/spec/acts_as_taggable_on/tag_spec.rb

@@ -1,115 +1,325 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'db/migrate/2_add_missing_unique_indices.rb'
 
-describe Tag do
+
+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
-    clean_database!
-    @tag = Tag.new
-    @user = TaggableModel.create(:name => "Pablo")
+    @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 "named like any" do
+  describe 'find or create by name' do
     before(:each) do
-      Tag.create(:name => "awesome")
-      Tag.create(:name => "epic")
+      @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 find both tags" do
-      Tag.named_like_any(["awesome", "epic"]).should have(2).items
+    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 name" do
+  describe 'find or create by unicode name', unless: using_sqlite? do
     before(:each) do
-      @tag.name = "awesome"
+      @tag.name = 'привет'
       @tag.save
     end
 
-    it "should find by name" do
-      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('привет')).to eq(@tag)
     end
 
-    it "should find by name case insensitive" do
-      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('ПРИВЕТ')).to eq(@tag)
     end
 
-    it "should create by name" do
-      lambda {
-        Tag.find_or_create_with_like_by_name("epic")
-      }.should change(Tag, :count).by(1)
+    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
+  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
-      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
+      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 find by name case insensitive" do
-      Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
+    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
 
-    it "should create by name" do
-      lambda {
-        Tag.find_or_create_all_with_like_by_name("epic")
-      }.should change(Tag, :count).by(1)
+    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
-      lambda {
-        Tag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
-      }.should change(Tag, :count).by(1)
+    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
-      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?
-    
-    if ActiveRecord::VERSION::MAJOR >= 3
-      @tag.errors[:name].should == ["can't be blank"]
-    else
-      @tag.errors[:name].should == "can't be blank"
-    end
+    #TODO, we should find another way to check this
+    expect(@tag.errors[:name]).to eq(["can't be blank"])
 
-    @tag.name = "something"
+    @tag.name = 'something'
     @tag.valid?
-    
-    if ActiveRecord::VERSION::MAJOR >= 3      
-      @tag.errors[:name].should == []
-    else
-      @tag.errors[:name].should be_nil
-    end
+
+    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 = 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!
-    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 = Tag.create!(:name => "coolip")
-    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
+    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