ffakerTW 0.1.0 → 1.1.0

data/test/test_address_ch_fr.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressCHFR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(FFakerTW::AddressCHFR, :canton)
-
-  def test_ch_fr_canton
-    assert_match(/\A[- a-zàâäèéêëîïôœùûüÿç]+\z/i, FFakerTW::AddressCHFR.canton)
-  end
-end

data/test/test_address_ch_it.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressCHIT < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(FFakerTW::AddressCHIT, :canton)
-
-  def test_ch_it_canton
-    FFakerTW::AddressCHIT::CANTON.each do |canton|
-      assert_match(/\A[- a-zàâ]+\z/i, canton)
-    end
-  end
-end

data/test/test_address_da.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressDA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressDA,
-    :city, :full_address, :kommune, :post_nr, :region, :state, :street_address,
-    :street_name, :zip_code
-  )
-
-  def test_zip_code
-    assert_match(/\A\d{4}\z/, FFakerTW::AddressDA.zip_code)
-  end
-
-  def test_post_nr
-    assert_match(/\A\d{4}\z/, FFakerTW::AddressDA.post_nr)
-  end
-
-  def test_state
-    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.state)
-  end
-
-  def test_kommune
-    assert_match(/\A[-ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.kommune)
-  end
-
-  def test_region
-    assert_match(/\A[ÆØÅæøåa-z-]+\z/i, FFakerTW::AddressDA.region)
-  end
-
-  def test_city
-    assert_match(/\A[- ÆØÅæøåla-z-]+\z/i, FFakerTW::AddressDA.city)
-  end
-
-  def test_street_name
-    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFakerTW::AddressDA.street_name)
-  end
-
-  def test_street_address
-    assert_match(/\A[. éÆØÅæøåla-z0-9-]+\z/i, FFakerTW::AddressDA.street_address)
-  end
-
-  def test_full_address
-    assert_match(/\A[. éÆØÅæøåla-z0-9-]+ DANMARK\z/i,
-                 FFakerTW::AddressDA.full_address)
-  end
-end

data/test/test_address_de.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressDE < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressDE,
-    :city, :state, :street_address, :street_name, :zip_code
-  )
-
-  def test_city
-    assert_match(/[ a-z]+/, FFakerTW::AddressDE.city)
-  end
-
-  def test_state
-    assert_match(/[ a-z]/, FFakerTW::AddressDE.state)
-  end
-
-  def test_zip_code
-    assert_match(/^\d{5}$/, FFakerTW::AddressDE.zip_code)
-  end
-
-  def test_street_name
-    assert_match(/[ a-z]+/, FFakerTW::AddressDE.street_name)
-  end
-
-  def test_street_address
-    assert_match(/[ a-z]+/, FFakerTW::AddressDE.street_address)
-  end
-end

data/test/test_address_fi.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressFI < Test::Unit::TestCase
-  include DeterministicHelper
-
-  ALPHA = /\A\p{Alpha}+/.freeze
-  DIGIT = /\d{1}/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressFI,
-    :city, :full_address, :random_country, :zip_code
-  )
-
-  def test_fi_city
-    assert_match(ALPHA, FFakerTW::AddressFI.city)
-  end
-
-  def test_fi_zip_code
-    assert_match(/\d{2}/, FFakerTW::AddressFI.zip_code)
-  end
-
-  def test_countries
-    assert FFakerTW::AddressFI::COUNTRIES.include?(FFakerTW::AddressFI.random_country)
-  end
-
-  def test_fi_full_address
-    address = FFakerTW::AddressFI.full_address
-    assert_match(ALPHA, address)
-    assert_match(DIGIT, address)
-    assert_match(/SUOMI/, address)
-    assert_match(/[, a-z]/, address)
-  end
-
-  def test_fi_zip_code_frozen
-    assert FFakerTW::AddressFI.zip_code.frozen? == false
-  end
-end

data/test/test_address_fr.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressFR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressFR,
-    :city, :full_address, :street_name, :postal_code, :region
-  )
-end

data/test/test_address_gr.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressGR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressGR,
-    :city, :region, :zip_code, :street_name, :street_nbr, :street_address
-  )
-
-  def setup
-    @address_gr = FFakerTW::AddressGR
-    @street_prefix = FFakerTW::AddressGR::STREET_PREFIX.join('|')
-  end
-
-  def test_city
-    assert_match(/\p{Greek}/, @address_gr.city)
-  end
-
-  def test_region
-    assert_match(/\p{Greek}/, @address_gr.region)
-  end
-
-  def test_zip_code
-    assert_match(/\A\d{5}\z/, @address_gr.zip_code)
-  end
-
-  def test_street_name
-    assert_match(/\p{Greek}/, @address_gr.street_name)
-  end
-
-  def test_street_nbr
-    assert_match(/\A\d{1,3}\z/, @address_gr.street_nbr)
-  end
-
-  def test_street_address
-    address = FFakerTW::AddressGR.street_address
-    assert_match(/#{@street_prefix}/, address)
-    assert_match(/\p{Greek}/, address)
-  end
-end

data/test/test_address_id.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressID < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressID,
-    :zip_code, :state, :state_abbr, :city, :street_prefix, :street
-  )
-
-  def test_zip_code
-    assert_match(/\A\d{5}\z/, FFakerTW::AddressID.zip_code)
-  end
-
-  def test_state
-    assert FFakerTW::AddressID::STATE.include?(FFakerTW::AddressID.state)
-  end
-
-  def test_state_abbr
-    assert FFakerTW::AddressID::STATE_ABBR.include?(FFakerTW::AddressID.state_abbr)
-  end
-
-  def test_city
-    assert_include FFakerTW::AddressID::CITY, FFakerTW::AddressID.city
-  end
-
-  def test_street_prefix
-    assert FFakerTW::AddressID::STREET_PREFIX.include?(FFakerTW::AddressID.street_prefix)
-  end
-
-  def test_street
-    prefixes = FFakerTW::AddressID::STREET_PREFIX
-    common_street_names = FFakerTW::AddressID::COMMON_STREET_NAMES
-    regex = /\A(#{prefixes.join('|')})\.(\s(#{common_street_names.join('|')})),\sNo\.\s\d+\z/
-    assert_match(regex, FFakerTW::AddressID.street)
-  end
-end

data/test/test_address_in.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressININ < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressIN,
-    :country_code, :country, :pincode, :state_abbr,
-    :state_and_union_territory_abbr, :state_and_union_territory, :state,
-    :time_zone, :union_territory_abbr, :union_territory
-  )
-
-  def test_in_state
-    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFakerTW::AddressIN.state)
-  end
-
-  def test_in_state_abbr
-    assert_match(/\A[A-Z]{2}\z/, FFakerTW::AddressIN.state_abbr)
-  end
-
-  def test_in_union_territory
-    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFakerTW::AddressIN.union_territory)
-  end
-
-  def test_in_union_territory_abbr
-    assert_match(/\A[A-Z]{2}\z/, FFakerTW::AddressIN.union_territory_abbr)
-  end
-
-  def test_in_state_and_union_territory
-    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFakerTW::AddressIN.state_and_union_territory)
-  end
-
-  def test_in_state_and_union_territory_abbr
-    assert_match(/\A[A-Z]{2}\z/, FFakerTW::AddressIN.state_and_union_territory_abbr)
-  end
-
-  def test_pincode
-    assert_match(/[0-9]{6}/, FFakerTW::AddressIN.pincode)
-  end
-
-  def test_zip_code
-    assert_match(/[0-9]{6}/, FFakerTW::AddressIN.pincode)
-  end
-
-  def test_in_country
-    assert_equal 'India', FFakerTW::AddressIN.country
-  end
-
-  def test_in_country_code
-    assert_equal 'IN', FFakerTW::AddressIN.country_code
-  end
-
-  def test_in_time_zone
-    assert_equal 'Asia/Kolkata', FFakerTW::AddressIN.time_zone
-  end
-end

data/test/test_address_it.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressIT < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressIT,
-    :city, :full_address, :street_address, :postal_code, :region
-  )
-end

data/test/test_address_ja.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressJA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressJA,
-    :address,  :other_address, :designated_city_address, :tokyo_ward_address,
-    :zip_code, :land_number, :tokyo_ward, :ward, :village, :city, :county,
-    :prefecture
-  )
-
-  def test_postal_code
-    assert_match(/^\d{3}-\d{4}$/, FFakerTW::AddressJA.postal_code)
-  end
-
-  def test_land_number
-    assert_match(/^\d丁目\d番\d号|\d{3}$/, FFakerTW::AddressJA.land_number)
-  end
-
-  def test_street
-    assert_match(japanese_regex(''), FFakerTW::AddressJA.street)
-  end
-
-  def test_tokyo_ward
-    assert_match(japanese_regex('区'), FFakerTW::AddressJA.tokyo_ward)
-  end
-
-  def test_ward
-    assert_match(japanese_regex('区'), FFakerTW::AddressJA.ward)
-  end
-
-  def test_village
-    assert_match(japanese_regex('村'), FFakerTW::AddressJA.village)
-  end
-
-  def test_designated_city
-    assert_match(japanese_regex('[市区]'), FFakerTW::AddressJA.city)
-  end
-
-  def test_city
-    assert_match(japanese_regex('市'), FFakerTW::AddressJA.city)
-  end
-
-  def test_county
-    assert_match(japanese_regex('郡'), FFakerTW::AddressJA.county)
-  end
-
-  def test_prefecture
-    assert_match(japanese_regex('[都道府県]'), FFakerTW::AddressJA.prefecture)
-  end
-
-  def japanese_regex(word)
-    /\A(?:\p{Hiragana}|\p{Katakana}|[ー－]|[一-龠々])+#{word}\z/
-  end
-end

data/test/test_address_kr.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressKR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressKR,
-    :postal_code, :old_postal_code, :road_addess, :land_address, :land_number,
-    :building_name, :address_detail, :street, :town, :borough, :city, :province,
-    :metropolitan_city
-  )
-end

data/test/test_address_mx.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressMX < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressMX,
-    :municipality, :postal_code, :state_abbr, :state, :zip_code
-  )
-
-  def test_mx_state
-    assert_match(/[\sa-z]/i, FFakerTW::AddressMX.state)
-  end
-
-  def test_mx_state_abbr
-    assert_match(/[A-Z]/, FFakerTW::AddressMX.state_abbr)
-  end
-
-  def test_postal_code
-    assert_match(/[0-9]/, FFakerTW::AddressMX.postal_code)
-  end
-
-  def test_zip_code
-    assert_match(/[0-9]/, FFakerTW::AddressMX.zip_code)
-  end
-
-  def test_mx_municipality
-    assert_match(/[\sa-z]/i, FFakerTW::AddressMX.municipality)
-  end
-end

data/test/test_address_nl.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressNL < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressNL,
-    :city, :province, :street_address, :street_name, :zip_code
-  )
-
-  def setup
-    @tester = FFakerTW::AddressNL
-  end
-
-  def test_city
-    assert_match(/[ a-z]+/, @tester.city)
-  end
-
-  def test_province
-    assert_match(/[ a-z]/, @tester.province)
-  end
-
-  def test_zip_code
-    assert_match(/\A[1-9]\d{3} [A-RT-Z][A-Z]\z/, @tester.zip_code)
-  end
-
-  def test_street_name
-    assert_match(/[ a-z]+/, @tester.street_name)
-  end
-
-  def test_street_address
-    assert_match(/[ a-z]+/, @tester.street_address)
-  end
-end

data/test/test_address_pl.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerAddressPL < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressPL,
-    :full_address, :street_address, :street_name, :street, :square, :voivodeship,
-    :voivodeship_abbr, :voivodeship_capital_city, :city, :building_number,
-    :secondary_number, :postal_code, :street_prefix, :square_prefix
-  )
-
-  def setup
-    @tester = FFakerTW::AddressPL
-  end
-
-  def test_full_address
-    assert_match(/[a-z]/, @tester.full_address)
-  end
-
-  def test_full_address_includes_country
-    assert_match(/POLOGNE/, @tester.full_address(true))
-  end
-
-  def street_address
-    assert_match(/[a-z]/, @tester.street_address)
-  end
-
-  def street_name
-    prefix, street = @tester.street_name.split
-    assert_include(@tester::STREET_PREFIXES + @tester::SQUARE_PREFIXES, prefix)
-    assert_include(@tester::STREET + @tester::SQUARE, street)
-  end
-
-  def street
-    assert_include(@tester::STREET, @tester.street)
-  end
-
-  def square
-    assert_include(@tester::SQUARE, @tester.square)
-  end
-
-  def voivodeship
-    assert_include(@tester::VOIVODESHIP, @tester.voivodeship)
-  end
-
-  def voivodeship_abbr
-    assert_include(@tester::VOIVODESHIP_ABBR, @tester.voivodeship_abbr)
-  end
-
-  def voivodeship_capital_city
-    assert_include(@tester::VOIVODESHIP_CAPITAL_CITY, @tester.voivodeship_capital_city)
-  end
-
-  def city
-    assert_include(@tester::CITY, @tester.city)
-  end
-
-  def building
-    assert_match(/\d{1,3}/, @tester.building)
-  end
-
-  def secondary_number
-    assert_match(/\d{1,3}/, @tester.secondary_number.split.last)
-  end
-
-  def postal_code
-    assert_match(/\d{2}-\d{3}/, @tester.postal_code)
-  end
-
-  def street_prefix
-    assert_include(@tester::STREET_PREFIXES, @tester.square_prefix)
-  end
-
-  def square_prefix
-    assert_include(@tester::SQUARE_PREFIXES, @tester.square_prefix)
-  end
-end

data/test/test_address_ru.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressRU < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressRU,
-    :city, :province, :street_address, :street_name, :zip_code
-  )
-
-  def setup
-    @tester = FFakerTW::AddressRU
-  end
-
-  def test_city
-    assert_match(/\A[a-zа-яё\-\s]+\z/i, @tester.city)
-  end
-
-  def test_province
-    assert_match(/\A[a-zа-яё\-\s]+\z/i, @tester.province)
-  end
-
-  def test_zip_code
-    assert_match(/\A\d{6}\z/, @tester.zip_code)
-  end
-
-  def test_street_name
-    assert_match(/\A[a-zа-яё.\-\s]+\z/i, @tester.street_name)
-  end
-
-  def test_street_address
-    assert_match(/\A[a-zа-яё.,\-\s\d]+\z/i, @tester.street_address)
-  end
-end

data/test/test_address_se.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressSE < Test::Unit::TestCase
-  include DeterministicHelper
-
-  ALPHA = /\A\p{Alpha}+/.freeze
-  DIGIT = /\d{1}/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressSE,
-    :city, :random_country, :full_address, :zip_code
-  )
-
-  def test_se_city
-    assert_match(ALPHA, FFakerTW::AddressSE.city)
-  end
-
-  def test_se_zip_code
-    assert_match(/\d{2}/, FFakerTW::AddressSE.zip_code)
-  end
-
-  def test_countries
-    assert FFakerTW::AddressSE::COUNTRIES.include?(FFakerTW::AddressSE.random_country)
-  end
-
-  def test_se_full_address
-    address = FFakerTW::AddressSE.full_address
-    assert_match(ALPHA, address)
-    assert_match(DIGIT, address)
-    assert_match(/SVERIGE/, address)
-    assert_match(/[, a-z]/, address)
-  end
-
-  def test_se_zip_code_frozen
-    assert FFakerTW::AddressSE.zip_code.frozen? == false
-  end
-end

data/test/test_address_sn.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestAddressSn < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::AddressSN,
-    :region, :departement, :arrondissement
-  )
-
-  def setup
-    @subject = FFakerTW::AddressSN
-  end
-
-  def test_region
-    assert FFakerTW::AddressSN::REGIONS.include?(FFakerTW::AddressSN.region)
-  end
-
-  def test_departement
-    assert FFakerTW::AddressSN::DEPARTEMENTS.include?(FFakerTW::AddressSN.departement)
-  end
-
-  def test_arrondissement
-    assert FFakerTW::AddressSN::ARRONDISSEMENTS.include?(FFakerTW::AddressSN.arrondissement)
-  end
-end