countries 3.0.0 → 5.2.0

data/spec/country_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'spec_helper'
 NUM_OF_COUNTRIES = 249
@@ -43,12 +43,16 @@ describe ISO3166::Country do
     expect(country.alpha3).to eq('USA')
   end
 
-  it 'should return 3166 name' do
-    expect(country.name).to eq('United States of America')
+  it 'should return 3166 iso_short_name' do
+    expect(country.iso_short_name).to eq('United States of America')
   end
 
   it 'should return alternate names' do
-    expect(country.names).to eq(['United States', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
+    expect(country.unofficial_names).to eq(["United States", "USA",
+                                            "Vereinigte Staaten von Amerika",
+                                            "États-Unis", "Estados Unidos",
+                                            "アメリカ合衆国", "Verenigde Staten",
+                                            "Соединенные Штаты Америки"])
   end
 
   it 'should return translations' do
@@ -65,15 +69,7 @@ describe ISO3166::Country do
   end
 
   it 'should return bounds' do
-    expect(country.bounds['northeast']['lat']).to eq(71.5388001)
-  end
-
-  it 'should return the decimal Latitude' do
-    expect(country.latitude_dec).to eq('39.44325637817383')
-  end
-
-  it 'should return the decimal Longitude' do
-    expect(country.longitude_dec).to eq('-98.95733642578125')
+    expect(country.bounds['northeast']['lat']).to eq(71.3577635769)
   end
 
   it 'should return continent' do
@@ -85,8 +81,18 @@ describe ISO3166::Country do
   end
 
   it 'knows when a country does not require postal codes' do
-    ireland = ISO3166::Country.search('IE')
-    expect(ireland.postal_code).to eq(false)
+    antarctica = ISO3166::Country.search('AQ')
+    expect(antarctica.postal_code).to eq(false)
+  end
+
+  it 'knows about the country postal code format' do
+    expect(country.postal_code_format).to_not be_nil
+
+    regex = Regexp.new(country.postal_code_format)
+    expect(regex).to match('12345-6789')
+
+    antarctica = ISO3166::Country.search('AQ')
+    expect(antarctica.postal_code_format).to be_nil
   end
 
   it 'should return region' do
@@ -101,12 +107,20 @@ describe ISO3166::Country do
     expect(country.world_region).to eq('AMER')
   end
 
-  context 'with Turkey' do
+  context 'with Türkiye' do
     let(:country) { ISO3166::Country.search('TR') }
 
     it 'should indicate EMEA as the world region' do
       expect(country.world_region).to eq('EMEA')
     end
+
+    it 'has iso_short_name Türkiye' do
+      expect(country.iso_short_name).to eq('Türkiye')
+    end
+
+    it 'has iso_long_name Republic of Türkiye' do
+      expect(country.iso_long_name).to eq('The Republic of Türkiye')
+    end
   end
 
   context 'with Japan' do
@@ -121,7 +135,7 @@ describe ISO3166::Country do
     let(:country) { ISO3166::Country.search('BE') }
 
     it 'should return its local names based on its languages' do
-      expect(country.local_names).to match_array(%w(België Belgique Belgien))
+      expect(country.local_names).to match_array(%w[België Belgique Belgien])
     end
 
     it 'should return its first local name' do
@@ -134,7 +148,7 @@ describe ISO3166::Country do
       before do
         ISO3166::Data.register(
           alpha2: 'BR2',
-          name: 'Brazil',
+          iso_short_name: 'Brazil',
           languages_official: %w(pt-BR),
           translations: {
             'pt-BR' => 'Translation for pt-BR',
@@ -158,7 +172,7 @@ describe ISO3166::Country do
       before do
         ISO3166::Data.register(
           alpha2: 'BR2',
-          name: 'Brazil',
+          iso_short_name: 'Brazil',
           languages_official: %w(pt-BR),
           translations: {
             'pt' => 'Translation for pt'
@@ -217,17 +231,17 @@ describe ISO3166::Country do
   end
 
   describe 'subdivisions' do
-    let(:virginia) { country.states['VA'] }
+    let(:virginia) { country.subdivisions['VA'] }
     it 'should return an empty hash for a country with no ISO3166-2' do
       expect(ISO3166::Country.search('VA').subdivisions.size).to eq(0)
     end
 
     it 'should return a hash with all sub divisions' do
-      expect(country.subdivisions.size).to eq(60)
+      expect(country.subdivisions.size).to eq(57)
     end
 
-    it 'should be available through states' do
-      expect(country.states.size).to eq(60)
+    it '#states should be deprecated' do
+      expect {country.states}.to output.to_stderr
     end
 
     it 'should be a subdivision object' do
@@ -238,11 +252,69 @@ describe ISO3166::Country do
       expect(virginia.name).to eq('Virginia')
     end
 
+    it 'should have a code' do
+      expect(virginia.code).to eq('VA')
+    end
+
     it 'should behave like a hash' do
       expect(virginia['name']).to eq('Virginia')
     end
   end
 
+  describe 'subdivision_types' do
+    it "should return an array of subdivision types" do
+      expect(country.subdivision_types).to contain_exactly('district', 'state', 'outlying_area')
+    end
+
+    it "should return an array of subdivision types even if there is only a single type" do
+      expect(ISO3166::Country['LI'].subdivision_types).to contain_exactly('commune')
+    end
+
+    it "should return an empty array if country has no subdivisions" do
+      expect(ISO3166::Country['AS'].subdivisions?).to be_falsey
+      expect(ISO3166::Country['AS'].subdivision_types).to eq([])
+    end
+  end
+
+  describe 'subdivisions_of_types' do
+    it "given a single type, should return an array of subdivisions that match the type" do
+      us_states = country.subdivisions_of_types(%w[state])
+      expect(us_states.size).to eq(50)
+      dc = country.subdivisions_of_types(%w[district])
+      expect(dc.size).to eq(1)
+    end
+
+    it "given multiple types, should return an array of subdivisions matching the types" do
+      us_states_plus_dc = country.subdivisions_of_types(%w[state district])
+      expect(us_states_plus_dc.size).to eq(51)
+    end
+
+    it "given multiple types where at least one does not exist for that country, should work without issue" do
+      us_states_plus_dc = country.subdivisions_of_types(%w[state district governorate])
+      expect(us_states_plus_dc.size).to eq(51)
+    end
+
+    it "given only types that do not exist for that country, should return an empty collection" do
+      should_be_empty = ISO3166::Country['PT'].subdivisions_of_types(%w[state county])
+      expect(should_be_empty).to be_empty
+    end
+  end
+
+  describe 'humanized_subdivision_types' do
+    it "should return an array of humanized subdivision types" do
+      expect(country.humanized_subdivision_types).to contain_exactly('District', 'State', 'Outlying area')
+    end
+
+    it "should return an array of subdivision types even if there is only a single type" do
+      expect(ISO3166::Country['LI'].humanized_subdivision_types).to contain_exactly('Commune')
+    end
+
+    it "should return an empty array if country has no subdivisions" do
+      expect(ISO3166::Country['AS'].subdivisions?).to be_falsey
+      expect(ISO3166::Country['AS'].humanized_subdivision_types).to eq([])
+    end
+  end
+
   describe 'subdivision_names_with_codes' do
     it 'should return an alphabetized list of all subdivisions names with codes' do
       subdivisions = ISO3166::Country.search('EG').subdivision_names_with_codes
@@ -253,7 +325,7 @@ describe ISO3166::Country do
     end
 
     it 'should return an alphabetized list of subdivision names translated to current locale with codes' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       subdivisions = ISO3166::Country.search('EG').subdivision_names_with_codes(:es)
       expect(subdivisions).to be_an(Array)
@@ -309,7 +381,7 @@ describe ISO3166::Country do
     end
 
     it 'should allow to customize each country representation passing a block to the method' do
-      countries = ISO3166::Country.all { |country, data| [data['name'], country, data['country_code']] }
+      countries = ISO3166::Country.all { |country, data| [data['iso_short_name'], country, data['country_code']] }
       expect(countries).to be_an(Array)
       expect(countries.first).to be_an(Array)
       expect(countries.first.size).to eq(3)
@@ -322,7 +394,7 @@ describe ISO3166::Country do
       countries = ISO3166::Country.all_translated('fr')
       expect(countries).to be_an(Array)
       expect(countries.first).to be_a(String)
-      expect(countries.first).to eq('Afghanistan')
+      expect(countries.first).to eq('Andorre')
       # countries missing the desired locale will not be added to the list
       # so all 250 countries may not be returned, 'fr' returns 249, for example
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
@@ -332,9 +404,29 @@ describe ISO3166::Country do
       countries = ISO3166::Country.all_translated
       expect(countries).to be_an(Array)
       expect(countries.first).to be_a(String)
-      expect(countries.first).to eq('Afghanistan')
+      expect(countries.first).to eq('Andorra')
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
+
+    context 'with custom countries' do
+      before do
+        ISO3166::Data.register(
+          alpha2: 'XX',
+          iso_short_name: 'Custom Country',
+          translations: { 'en' => 'Custom Country' }
+        )
+      end
+
+      it 'should include custom registered countries' do
+        custom_country = ISO3166::Country.find_by_alpha2('XX')[1]
+        countries = ISO3166::Country.all_translated
+        expect(countries).to include(custom_country['iso_short_name'])
+      end
+
+      after do
+        ISO3166::Data.unregister('XX')
+      end
+    end
   end
 
   describe 'all_names_with_codes' do
@@ -345,11 +437,11 @@ describe ISO3166::Country do
       expect(countries.first[0]).to be_a(String)
       expect(countries.first[0]).to eq('Afghanistan')
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
-      expect(countries.any?{|pair| !pair[0].html_safe?}).to eq(false)
+      expect(countries.any? { |pair| !pair[0].html_safe? }).to eq(false)
     end
 
     it 'should return an alphabetized list of all country names translated to current locale with ISOCODE alpha2' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       countries = ISO3166::Country.all_names_with_codes(:es)
       expect(countries).to be_an(Array)
@@ -369,7 +461,7 @@ describe ISO3166::Country do
     end
 
     it 'should return an alphabetized list of all country names translated to current locale with ISOCODE alpha2' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       countries = ISO3166::Country.all_names_with_codes(:es)
       expect(countries).to be_an(Array)
@@ -381,7 +473,7 @@ describe ISO3166::Country do
 
   describe 'translation' do
     it 'should return the localized name for a country to the selected locale' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
       countries = ISO3166::Country.new(:de).translation('de')
       expect(countries).to be_an(String)
       expect(countries).to eq('Deutschland')
@@ -397,14 +489,31 @@ describe ISO3166::Country do
       countries = ISO3166::Country.new(:de).translation('xxx')
       expect(countries).to be_nil
     end
+
+    context 'should return variant locales' do
+      it 'should return different value for Chinese variants' do
+        ISO3166.configuration.locales = %i[zh-cn zh-hk zh-tw]
+        name_cn = ISO3166::Country['TW'].translation('zh-cn')
+        name_hk = ISO3166::Country['TW'].translation('zh-hk')
+        name_tw = ISO3166::Country['TW'].translation('zh-tw')
+        expect([name_cn, name_hk, name_tw].uniq.size).to eql 3
+      end
+
+      it 'should return different value for Portuguese variants' do
+        ISO3166.configuration.locales = %i[pt pt-br]
+        name_pt = ISO3166::Country['SG'].translation('pt')
+        name_br = ISO3166::Country['SG'].translation('pt-br')
+        expect([name_pt, name_br].uniq.size).to eql 2
+      end
+    end
   end
 
   describe 'translations' do
     it 'should return an hash of all country names translated to the selected locale' do
       countries = ISO3166::Country.translations('fr')
       expect(countries).to be_an(Hash)
-      expect(countries.first[0]).to eq('AF')
-      expect(countries.first).to eq(%w(AF Afghanistan))
+      expect(countries.first[0]).to eq('AD')
+      expect(countries.first).to eq(%w[AD Andorre])
       # countries missing the desired locale will not be added to the list
       # so all 250 countries may not be returned, 'fr' returns 249, for example
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
@@ -413,8 +522,8 @@ describe ISO3166::Country do
     it 'should return an hash of all country names in English if no locale is passed' do
       countries = ISO3166::Country.translations
       expect(countries).to be_an(Hash)
-      expect(countries.first[0]).to eq('AF')
-      expect(countries.first).to eq(%w(AF Afghanistan))
+      expect(countries.first[0]).to eq('AD')
+      expect(countries.first).to eq(%w[AD Andorra])
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
@@ -498,29 +607,42 @@ describe ISO3166::Country do
     end
 
     it 'also performs searches with regexps and forces it to ignore case' do
-      spain_data = ISO3166::Country.find_all_by(:names, /Españ/)
+      spain_data = ISO3166::Country.find_all_by(:unofficial_names, /Españ/)
       expect(spain_data).to be_a Hash
       expect(spain_data.keys).to eq(['ES'])
     end
+
+    it 'performs reasonably' do
+      start = Time.now
+      250.times do
+        lookup = ['ZM', 'ZMB', 'Zambia', 'US', 'USA', 'United States'].sample
+        case lookup.length
+        when 2 then ISO3166::Country.find_all_by(:alpha2, lookup)
+        when 3 then ISO3166::Country.find_all_by(:alpha3, lookup)
+        else ISO3166::Country.find_all_by(:iso_short_name, lookup)
+        end
+      end
+      expect(Time.now - start).to be < 1
+    end
   end
 
   describe 'hash finder methods' do
-    context "when search name in 'name'" do
-      subject { ISO3166::Country.find_by_name('Poland') }
+    context "when search name in 'iso_short_name'" do
+      subject { ISO3166::Country.find_by_iso_short_name('Poland') }
       it 'should return' do
         expect(subject.first).to eq('PL')
       end
     end
 
-    context "when search lowercase name in 'name'" do
-      subject { ISO3166::Country.find_by_name('poland') }
+    context "when search lowercase name in 'iso_short_name'" do
+      subject { ISO3166::Country.find_by_iso_short_name('poland') }
       it 'should return' do
         expect(subject.first).to eq('PL')
       end
     end
 
-    context "when search name with comma in 'name'" do
-      subject { ISO3166::Country.find_by_name(country_name) }
+    context "when search name with comma in 'iso_short_name'" do
+      subject { ISO3166::Country.find_by_iso_short_name(country_name) }
 
       context 'with Republic of Korea' do
         let(:country_name) { 'Korea, Republic of' }
@@ -545,7 +667,7 @@ describe ISO3166::Country do
     end
 
     context 'when search lowercase multibyte name found' do
-      subject { ISO3166::Country.find_country_by_name('россия') }
+      subject { ISO3166::Country.find_country_by_unofficial_names('россия') }
 
       it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
@@ -554,7 +676,7 @@ describe ISO3166::Country do
     end
 
     context 'when search lowercase multibyte name found' do
-      subject { ISO3166::Country.find_country_by_name(/россия/) }
+      subject { ISO3166::Country.find_country_by_unofficial_names(/россия/) }
 
       it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
@@ -563,7 +685,7 @@ describe ISO3166::Country do
     end
 
     context 'when accents are not used' do
-      subject { ISO3166::Country.find_country_by_name('emirats Arabes Unis') }
+      subject { ISO3166::Country.find_country_by_unofficial_names('emirats Arabes Unis') }
 
       it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
@@ -571,8 +693,20 @@ describe ISO3166::Country do
       end
     end
 
-    context "when search name in 'names'" do
-      subject { ISO3166::Country.find_by_name('Polonia') }
+    context "when search name in 'unofficial_names'" do
+      subject { ISO3166::Country.find_by_unofficial_names('Polonia') }
+      it 'should return' do
+        expect(subject.first).to eq('PL')
+      end
+    end
+
+    context "when search name in 'translated_names'" do
+      before do
+        ISO3166.configure do |config|
+          config.locales = [:bs]
+        end
+      end
+      subject { ISO3166::Country.find_by_translated_names('Poljska') }
       it 'should return' do
         expect(subject.first).to eq('PL')
       end
@@ -580,7 +714,9 @@ describe ISO3166::Country do
 
     context 'when finding by invalid attribute' do
       it 'should raise an error' do
-        expect { ISO3166::Country.find_by_invalid('invalid') }.to raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        expect { ISO3166::Country.find_by_invalid('invalid') }.to(
+          raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        )
       end
     end
 
@@ -605,7 +741,7 @@ describe ISO3166::Country do
 
   describe 'country finder methods' do
     context 'when search name found' do
-      let(:uk) { ISO3166::Country.find_country_by_name('United Kingdom') }
+      let(:uk) { ISO3166::Country.find_country_by_unofficial_names('United Kingdom') }
 
       it 'should be a country instance' do
         expect(uk).to be_a(ISO3166::Country)
@@ -614,7 +750,7 @@ describe ISO3166::Country do
     end
 
     context 'when search lowercase name found' do
-      let(:uk) { ISO3166::Country.find_country_by_name('united kingdom') }
+      let(:uk) { ISO3166::Country.find_country_by_unofficial_names('united kingdom') }
 
       it 'should be a country instance' do
         expect(uk).to be_a(ISO3166::Country)
@@ -623,7 +759,7 @@ describe ISO3166::Country do
     end
 
     context 'when the search term contains comma' do
-      let(:korea) { ISO3166::Country.find_country_by_name('Korea, Republic of') }
+      let(:korea) { ISO3166::Country.find_country_by_unofficial_names('Korea, Republic of') }
 
       it 'should be a country instance' do
         expect(korea).to be_a(ISO3166::Country)
@@ -645,15 +781,88 @@ describe ISO3166::Country do
       end
     end
 
-    context 'regression test for #388' do
-      let(:no_country) { ISO3166::Country.find_country_by_translated_names(nil) }
+    describe '#find_country_by_any_name' do
+      context 'when search name found' do
+        let(:uk) { ISO3166::Country.find_country_by_any_name('United Kingdom') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+
+      context 'when search lowercase name found' do
+        let(:uk) { ISO3166::Country.find_country_by_any_name('united kingdom') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+
+      context 'when the search term contains comma' do
+        let(:korea) { ISO3166::Country.find_country_by_any_name('Korea, Republic of') }
+
+        it 'should be a country instance' do
+          expect(korea).to be_a(ISO3166::Country)
+          expect(korea.alpha2).to eq('KR')
+        end
+      end
+
+      context 'when search translation found' do
+        before do
+          ISO3166.configure do |config|
+            config.locales = [:bs]
+          end
+        end
+        let(:uk) { ISO3166::Country.find_country_by_any_name('Velika Britanija') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+    end
+
+    context 'sanity check for #771' do
+      let(:turkey) { ISO3166::Country.find_country_by_any_name('Turkey') }
 
       it 'should be a country instance' do
+        expect(turkey).to be_a(ISO3166::Country)
+        expect(turkey.alpha2).to eq('TR')
+      end
+    end
+
+    context 'regression test for #746' do
+      let(:no_country) { ISO3166::Country.find_country_by_any_name(nil) }
+
+      it 'should not be a country instance' do
         expect(no_country).to_not be_a(ISO3166::Country)
         expect(no_country).to eq nil
       end
     end
 
+    context 'regression test for #388/#746/#776' do
+      before do
+        ISO3166.configure do |config|
+          config.locales = [:af, :am, :ar, :as, :az, :be, :bg, :bn, :br, :bs, :ca, :cs, :cy, :da, :de, :dz, :el, :en, :eo, :es, :et, :eu, :fa, :fi, :fo, :fr, :ga, :gl, :gu, :he, :hi, :hr, :hu, :hy, :ia, :id, :is, :it, :ja, :ka, :kk, :km, :kn, :ko, :ku, :lt, :lv, :mi, :mk, :ml, :mn, :mr, :ms, :mt, :nb, :ne, :nl, :nn, :oc, :or, :pa, :pl, :ps, :pt, :ro, :ru, :rw, :si, :sk, :sl, :so, :sq, :sr, :sv, :sw, :ta, :te, :th, :ti, :tk, :tl, :tr, :tt, :ug, :uk, :ve, :vi, :wa, :wo, :xh, :zh, :zu]
+        end
+      end
+
+      let(:no_country) { ISO3166::Country.find_country_by_translated_names(nil) }
+      let(:zimbabwe) { ISO3166::Country['ZW'] }
+
+      it 'should not be a country instance' do
+        expect(no_country).to_not be_a(ISO3166::Country)
+        expect(no_country).to eq nil
+      end
+
+      it 'translated_names should not include nil values' do
+        expect(zimbabwe.translation('no')).to be_nil
+        expect(zimbabwe.translated_names).not_to include(nil)
+      end
+    end
+
     context 'when attempting to search by translations hash' do
       let(:uk) { ISO3166::Country.find_country_by_translations({}) }
 
@@ -661,8 +870,9 @@ describe ISO3166::Country do
         expect { uk }.to raise_error(RuntimeError)
       end
     end
+
     context 'when search name not found' do
-      let(:bogus) { ISO3166::Country.find_country_by_name('Does not exist') }
+      let(:bogus) { ISO3166::Country.find_country_by_unofficial_names('Does not exist') }
 
       it 'should be a country instance' do
         expect(bogus).to eq(nil)
@@ -671,7 +881,7 @@ describe ISO3166::Country do
 
     # Spot checks #243
     context 'when search name not found' do
-      let(:belgium) { ISO3166::Country.find_country_by_name('Belgium') }
+      let(:belgium) { ISO3166::Country.find_country_by_unofficial_names('Belgium') }
 
       it 'should be a country instance' do
         expect(belgium.alpha2).to eq('BE')
@@ -680,7 +890,7 @@ describe ISO3166::Country do
 
     # Spot checks #240
     context 'when search name not found' do
-      let(:canada) { ISO3166::Country.find_country_by_name('Canada') }
+      let(:canada) { ISO3166::Country.find_country_by_unofficial_names('Canada') }
 
       it 'should be a country instance' do
         expect(canada.alpha2).to eq('CA')
@@ -689,7 +899,7 @@ describe ISO3166::Country do
 
     # Spot checks #241
     context 'when search name not found' do
-      let(:israel) { ISO3166::Country.find_country_by_name('Israel') }
+      let(:israel) { ISO3166::Country.find_country_by_unofficial_names('Israel') }
 
       it 'should be a country instance' do
         expect(israel.alpha2).to eq('IL')
@@ -698,7 +908,7 @@ describe ISO3166::Country do
 
     # Spot checks #241
     context 'when search name not found' do
-      let(:israel) { ISO3166::Country.find_by_name('Israel') }
+      let(:israel) { ISO3166::Country.find_by_iso_short_name('Israel') }
 
       it 'should be a country instance' do
         expect(israel[0]).to eq('IL')
@@ -707,7 +917,7 @@ describe ISO3166::Country do
 
     # Spot checks #241
     context 'when search name not found' do
-      let(:israel) { ISO3166::Country.find_all_by(:name, 'Israel') }
+      let(:israel) { ISO3166::Country.find_all_by(:iso_short_name, 'Israel') }
 
       it 'should be a country instance' do
         expect(israel.size).to eq(1)
@@ -717,8 +927,9 @@ describe ISO3166::Country do
 
     context 'when finding by invalid attribute' do
       it 'should raise an error' do
-        expect { ISO3166::Country.find_country_by_invalid('invalid') }.to raise_error(RuntimeError,
-                                                                                      "Invalid attribute name 'invalid'")
+        expect { ISO3166::Country.find_country_by_invalid('invalid') }.to(
+          raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        )
       end
     end
 
@@ -740,13 +951,42 @@ describe ISO3166::Country do
     end
   end
 
-  describe 'names in Data' do
-    it 'should be unique (to allow .find_by_name work properly)' do
-      names = ISO3166::Data.cache.map do |_k, v|
-        [v['name'], v['unofficial_names']].flatten.uniq
-      end.flatten
+  describe 'finder methods respond_to_missing?' do
+    subject { ISO3166::Country.respond_to?(method_name) }
+    describe 'find_all_by' do
+      context 'find by a valid Country attribute' do
+        let(:method_name) { :find_all_by_currency }
+        it { is_expected.to be true }
+      end
 
-      expect(names.size).to eq(names.uniq.size)
+      context 'find by an invalid attribute' do
+        let(:method_name) { :find_all_by_invalid }
+        it { is_expected.to be false }
+      end
+    end
+
+    describe 'hash finder methods' do
+      context 'find by a valid Country attribute' do
+        let(:method_name) { :find_by_iso_short_name }
+        it { is_expected.to be true }
+      end
+
+      context 'find by an invalid attribute' do
+        let(:method_name) { :find_by_invalid }
+        it { is_expected.to be false }
+      end
+    end
+
+    describe 'country finder methods' do
+      context 'find country by a valid Country attribute' do
+        let(:method_name) { :find_country_by_alpha3 }
+        it { is_expected.to be true }
+      end
+
+      context 'find by an invalid attribute' do
+        let(:method_name) { :find_country_by_invalid }
+        it { is_expected.to be false }
+      end
     end
   end
 
@@ -798,6 +1038,23 @@ describe ISO3166::Country do
     end
   end
 
+  describe 'in_esm?' do
+    let(:netherlands) { ISO3166::Country.search('NL') }
+    let(:switzerland) { ISO3166::Country.search('CH') }
+
+    it 'should return false for countries without esm_member or eea_member flag' do
+      expect(country.in_esm?).to be_falsey
+    end
+
+    it 'should return true for countries with eea_member flag set to true' do
+      expect(netherlands.in_esm?).to be_truthy
+    end
+
+    it 'should return true for countries with esm_member flag set to true' do
+      expect(switzerland.in_esm?).to be_truthy
+    end
+  end
+
   describe 'gec' do
     it 'should return the country\'s GEC code' do
       expect(ISO3166::Country.new('NA').gec).to eql 'WA'
@@ -809,7 +1066,7 @@ describe ISO3166::Country do
   end
 
   describe 'to_s' do
-    it 'should return the country name' do
+    it 'should return the country iso_short_name' do
       expect(ISO3166::Country.new('GB').to_s).to eq('United Kingdom of Great Britain and Northern Ireland')
     end
   end
@@ -823,7 +1080,7 @@ describe ISO3166::Country do
 
     it 'should contain all keys for vat_rates' do
       expect(belgium.vat_rates).to be_a(Hash)
-      expect(belgium.vat_rates.keys).to eq(%w(standard reduced super_reduced parking))
+      expect(belgium.vat_rates.keys).to eq(%w[standard reduced super_reduced parking])
     end
 
     it 'should return an array of reduced vat rates' do
@@ -850,30 +1107,30 @@ describe ISO3166::Country do
 
   describe 'Added country names to search by' do
     it 'should return country code for Democratic Republic of the Congo' do
-      expect(ISO3166::Country.find_country_by_name('Democratic Republic of the Congo').alpha2).to eq 'CD'
+      expect(ISO3166::Country.find_country_by_unofficial_names('Democratic Republic of the Congo').alpha2).to eq 'CD'
     end
     it 'should return country code for Ivory Coast' do
-      expect(ISO3166::Country.find_country_by_name('Ivory Coast').alpha2).to eq 'CI'
+      expect(ISO3166::Country.find_country_by_unofficial_names('Ivory Coast').alpha2).to eq 'CI'
     end
     it 'should return Pakistan code for Guinea Bissau' do
-      expect(ISO3166::Country.find_country_by_name('Guinea Bissau').alpha2).to eq 'GW'
+      expect(ISO3166::Country.find_country_by_unofficial_names('Guinea Bissau').alpha2).to eq 'GW'
     end
     it 'should return Pakistan code for St Kitts and Nevis' do
-      expect(ISO3166::Country.find_country_by_name('St Kitts and Nevis').alpha2).to eq 'KN'
+      expect(ISO3166::Country.find_country_by_unofficial_names('St Kitts and Nevis').alpha2).to eq 'KN'
     end
     it 'should return Pakistan code for St Lucia' do
-      expect(ISO3166::Country.find_country_by_name('St Lucia').alpha2).to eq 'LC'
-      expect(ISO3166::Country.find_country_by_name('St. Lucia').alpha2).to eq 'LC'
+      expect(ISO3166::Country.find_country_by_unofficial_names('St Lucia').alpha2).to eq 'LC'
+      expect(ISO3166::Country.find_country_by_unofficial_names('St. Lucia').alpha2).to eq 'LC'
     end
     it 'should return Pakistan code for Turks and Caicos' do
-      expect(ISO3166::Country.find_country_by_name('Turks and Caicos').alpha2).to eq 'TC'
+      expect(ISO3166::Country.find_country_by_unofficial_names('Turks and Caicos').alpha2).to eq 'TC'
     end
     it 'should return Pakistan code for St Vincent Grenadines' do
-      expect(ISO3166::Country.find_country_by_name('St Vincent Grenadines').alpha2).to eq 'VC'
-      expect(ISO3166::Country.find_country_by_name('St. Vincent Grenadines').alpha2).to eq 'VC'
+      expect(ISO3166::Country.find_country_by_unofficial_names('St Vincent Grenadines').alpha2).to eq 'VC'
+      expect(ISO3166::Country.find_country_by_unofficial_names('St. Vincent Grenadines').alpha2).to eq 'VC'
     end
     it 'should return country code for Palestinian Authority' do
-      expect(ISO3166::Country.find_country_by_name('Palestinian Authority').alpha2).to eq 'PS'
+      expect(ISO3166::Country.find_country_by_unofficial_names('Palestinian Authority').alpha2).to eq 'PS'
     end
   end
 
@@ -891,4 +1148,24 @@ describe ISO3166::Country do
       expect(countries.all? { |country| country.un_locode.length == 2 }).to be
     end
   end
+
+  describe '.pluck' do
+    let(:args) { [] }
+
+    subject { ISO3166::Country.pluck(*args) }
+
+    it 'returns empty arrays' do
+      expect(subject.first).to be_empty
+      expect(subject.last).to be_empty
+    end
+
+    context "when asking for alpha2, alpha3 and iso_short_name" do
+      let(:args) { [:alpha2, :alpha3, :iso_short_name] }
+
+      it 'returns the correct values' do
+        expect(subject.first).to eq(%w[AD AND Andorra])
+        expect(subject.last).to eq(%w[ZW ZWE Zimbabwe])
+      end
+    end
+  end
 end