ffakerTW 0.1.0

data/test/test_gender_pl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerGenderPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  GENDER_REGEX = /\A(kobieta|mężczyzna)\z/.freeze
+
+  assert_methods_are_deterministic(FFakerTW::GenderPL, :random)
+
+  def setup
+    @tester = FFakerTW::GenderPL
+  end
+
+  def test_random
+    assert_match(GENDER_REGEX, @tester.random)
+  end
+
+  def test_sample
+    assert_match(GENDER_REGEX, @tester.sample)
+  end
+
+  def test_maybe
+    assert_match(GENDER_REGEX, @tester.maybe)
+  end
+end

data/test/test_gender_ru.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerGenderRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::GenderRU, :binary, :random)
+
+  def setup
+    @tester = FFakerTW::GenderRU
+  end
+
+  def test_random
+    gender_regex = /\A(?:мужчина|женщина|нонбайнари|агендер)\z/
+    assert_match(gender_regex, @tester.random)
+  end
+
+  def test_binary
+    gender_regex = /\A(?:мужчина|женщина)\z/
+    assert_match(gender_regex, @tester.binary)
+  end
+end

data/test/test_geolocation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestGeolocation < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Geolocation, :lat, :lng)
+
+  def test_lat
+    assert_match(/[0-9]+/, FFakerTW::Geolocation.lat.to_s)
+  end
+
+  def test_lng
+    assert_match(/[0-9]+/, FFakerTW::Geolocation.lng.to_s)
+  end
+
+  def test_boxed_coords
+    coords_list = [
+      [[1, 1], [3, 3]],
+      [[12.3455, 23.3434], [34.3434, 36.34343]],
+      [[12.3455, 23.3434], [10.3434, 6.34343]]
+    ]
+
+    coords_list.each do |coords|
+      lat_min = [coords[0][0], coords[1][0]].min
+      lat_max = [coords[0][0], coords[1][0]].max
+      lon_min = [coords[0][1], coords[1][1]].min
+      lon_max = [coords[0][1], coords[1][1]].max
+
+      new_coords = FFakerTW::Geolocation.boxed_coords(coords[0], coords[1])
+
+      assert (lat_min..lat_max).cover? new_coords[0]
+      assert (lon_min..lon_max).cover? new_coords[1]
+    end
+  end
+end

data/test/test_guid.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestGuid < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Guid, :guid)
+
+  def test_guid
+    assert_match(/[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/,
+                 FFakerTW::Guid.guid)
+  end
+end

data/test/test_healthcare_ipsum.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestHealthcareIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::HealthcareIpsum,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
+  def test_paragraph
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::HealthcareIpsum.paragraph)
+  end
+
+  def test_sentence
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::HealthcareIpsum.sentence)
+  end
+
+  def test_paragraphs
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::HealthcareIpsum.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::HealthcareIpsum.sentences.join(' '))
+  end
+
+  def test_words
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::HealthcareIpsum.words.join(' '))
+  end
+
+  def test_word
+    assert_match(/1\+|[a-z]+/i, FFakerTW::HealthcareIpsum.word)
+  end
+end

data/test/test_healthcare_ru.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestHealthcareRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  SPECIALIZATION_REGEX = /\A[А-Яа-я\ ()\-]+\z/.freeze
+
+  assert_methods_are_deterministic(FFakerTW::HealthcareRU, :doctor_specialization)
+
+  def setup
+    @tester = FFakerTW::HealthcareRU
+  end
+
+  def test_doctor_specialization
+    assert_match(SPECIALIZATION_REGEX, @tester.doctor_specialization)
+  end
+end

data/test/test_hipster_ipsum.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestHipsterIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::HipsterIpsum,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
+  TEST_REGEX = /\+1|[ a-z]+/i.freeze
+
+  def test_paragraph
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.paragraph)
+  end
+
+  def test_sentence
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.sentence)
+  end
+
+  def test_paragraphs
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.sentences.join(' '))
+  end
+
+  def test_words
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.words.join(' '))
+  end
+
+  def test_word
+    assert_match(TEST_REGEX, FFakerTW::HipsterIpsum.word)
+  end
+end

data/test/test_html_ipsum.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestHTMLIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::HTMLIpsum,
+    :a, :p, :dl, :ul_short, :ul_long, :ol_short, :ol_long, :ul_links,
+    :table, :body, :fancy_string
+  )
+
+  def setup
+    @tester = FFakerTW::HTMLIpsum
+  end
+
+  def test_a
+    assert_match(%r{^<a href="#\w+" title="[ \w]+">[ \w]+</a>$}i, FFakerTW::HTMLIpsum.a)
+  end
+
+  def test_p
+    # We can't predict the number of times the sentence pattern will repeat
+    # because the FFakerTW::Lorem methods that we are using adds a random
+    # number on top of what we specify for the count argument.
+    assert_match(%r{^<p>([ \w]+\.)+</p>$}i, FFakerTW::HTMLIpsum.p)
+  end
+
+  def test_p_breaks
+    # Here we can at least test how many <br> tags there are.
+    assert_match(%r{^<p>(?:[ \w.]+<br>){2}[ \w.]+</p>$}i, FFakerTW::HTMLIpsum.p(3, include_breaks: true))
+  end
+
+  def test_p_fancy
+    # We can't predict the number of times the sentence pattern will repeat
+    # because the FFakerTW::Lorem methods that we are using adds a random
+    # number on top of what we specify for the count argument. We also have to
+    # account for the other HTML that is being returned.
+    str = FFakerTW::HTMLIpsum.p(5, fancy: true)
+    assert_match(/^<p>/, str)
+    assert_match(%r{</p>$}, str)
+    assert str.length > 6, 'string contains more than <p></p>'
+  end
+
+  def test_p_fancy_breaks
+    # Here we can at least test how many <br> tags there are. We also have to
+    # account for the other HTML that is being returned.
+    str = FFakerTW::HTMLIpsum.p(10, fancy: true, include_breaks: true)
+    assert_equal 10, str.split('<br>').length
+  end
+
+  def test_dl
+    assert_match(%r{^<dl>(<dt>[ \w]+</dt><dd>[ \w.]+</dd>){3}</dl>$}i, FFakerTW::HTMLIpsum.dl(3))
+  end
+
+  def test_ul_short
+    assert_match(%r{^<ul>(<li>[ \w.]+</li>){3}</ul>$}i, FFakerTW::HTMLIpsum.ul_short(3))
+  end
+
+  def test_ul_long
+    assert_match(%r{^<ul>(<li>[ \w.]+</li>){3}</ul>$}i, FFakerTW::HTMLIpsum.ul_long(3))
+  end
+
+  def test_ol_short
+    assert_match(%r{^<ol>(<li>[ \w.]+</li>){3}</ol>$}i, FFakerTW::HTMLIpsum.ol_short(3))
+  end
+
+  def test_ol_long
+    assert_match(%r{^<ol>(<li>[ \w.]+</li>){3}</ol>$}i, FFakerTW::HTMLIpsum.ol_long(3))
+  end
+
+  def test_ul_links
+    assert_match(%r{^<ul>(<li><a href="#\w+" title="\w+">[ \w]+</a></li>){3}</ul>$}i, FFakerTW::HTMLIpsum.ul_links(3))
+  end
+
+  def test_table
+    assert_match(%r{(<td>[ \w]+</td>\s*){3}}i, FFakerTW::HTMLIpsum.table(3))
+  end
+
+  def test_body
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    assert_match(%r{^<h1>.+</pre>$}im, FFakerTW::HTMLIpsum.body)
+  end
+
+  def test_fancy_string
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    assert FFakerTW::HTMLIpsum.fancy_string.is_a?(String), 'returns a string'
+    assert FFakerTW::HTMLIpsum.fancy_string.length > 1, 'the string is longer than one char'
+  end
+
+  def test_fancy_string_tags
+    # It returns a string with at least one HTML tag
+    assert_match(%r{(<.*>[\w\s]+<\/\w+>){1}}i, FFakerTW::HTMLIpsum.fancy_string(1))
+    assert_match(%r{(<.*>[\w\s]+<\/\w+>){1}}i, FFakerTW::HTMLIpsum.fancy_string(3))
+  end
+
+  def test_fancy_string_breaks
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    str = FFakerTW::HTMLIpsum.fancy_string(3, true)
+    assert_equal 3, str.split('<br>').length
+  end
+end

data/test/test_identification.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentification < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Identification,
+    :drivers_license, :ssn, :gender, :ethnicity
+  )
+
+  def setup
+    @tester = FFakerTW::Identification
+  end
+
+  def test_drivers_license
+    ###-###-##-###-#
+    drivers_license_regex = /\A[A-Z]\d{3}-\d{3}-\d{2}-\d{3}-\d{1}\z/
+    assert_match(drivers_license_regex, @tester.drivers_license)
+  end
+
+  def test_ssn
+    assert_match(/\A\d{3}-\d{2}-\d{4}\z/, @tester.ssn)
+  end
+
+  def test_gender
+    assert_match(/\A(Male|Female)\z/, @tester.gender)
+  end
+
+  def test_ethnicity
+    ethnicity_regex = %r{\A(African American|Asian/Pacific Islander|Caucasian|Hispanic|Native American|Multiracial|Other|Prefer not to respond)\z}
+    assert_match(ethnicity_regex, @tester.ethnicity)
+  end
+end

data/test/test_identification_br.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationBR,
+    :cpf, :pretty_cpf, :cnpj, :pretty_cnpj, :rg, :pretty_rg, :gender
+  )
+
+  def setup
+    @tester = FFakerTW::IdentificationBR
+  end
+
+  def test_cpf
+    cpf = @tester.cpf
+    verification_digits = @tester.cpf_verification_digits(cpf[0..8])
+    assert(cpf[9..10] == verification_digits.join)
+    assert_match(/\A\d{11}\z/, cpf)
+  end
+
+  def test_pretty_cpf
+    assert_match(/\A\d{3}\.\d{3}\.\d{3}-\d{2}\z/, @tester.pretty_cpf)
+  end
+
+  def test_cnpj
+    cnpj = @tester.cnpj
+    verification_digits = @tester.cnpj_verification_digits(cnpj[0..11])
+    assert(cnpj[12..13] == verification_digits.join)
+    assert_match(/\A\d{14}\z/, cnpj)
+  end
+
+  def test_pretty_cnpj
+    assert_match(%r{\A\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}\z}, @tester.pretty_cnpj)
+  end
+
+  def test_rg
+    assert_match(/\A\d{9}\z/, @tester.rg)
+  end
+
+  def test_gender
+    assert_match(/\A(Feminino|Masculino)\z/, @tester.gender)
+  end
+end

data/test/test_identification_co.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationESCO < Test::Unit::TestCase
+  include Test::Unit::Assertions
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationESCO,
+    :drivers_license, :driver_license_category, :blood_type, :expedition_date
+  )
+
+  def setup
+    @tester = FFakerTW::IdentificationESCO
+  end
+
+  def test_drivers_license
+    assert_match(/\A\d{6,14}\z/, @tester.drivers_license)
+  end
+
+  def test_id
+    assert @tester.method_defined?(:id)
+  end
+
+  def test_gender
+    assert_match(/\A(Hombre|Mujer)\z/, @tester.gender)
+  end
+
+  def test_category
+    assert_match(/\A(a[1-2]|[bc][1-3])\z/i, @tester.driver_license_category)
+  end
+
+  def test_blood_type
+    assert_match(/\A(a|b|o|ab)[+-]\z/i, @tester.blood_type)
+  end
+
+  def test_expedition_date
+    assert_less_than @tester.expedition_date, Date.today
+  end
+end

data/test/test_identification_es.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationES < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::IdentificationES, :gender)
+
+  def setup
+    @tester = FFakerTW::IdentificationES
+  end
+
+  def test_gender
+    assert_match(/(Hombre|Mujer)/, @tester.gender)
+  end
+end

data/test/test_identification_es_cl.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationESCL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::IdentificationESCL, :rut)
+
+  def setup
+    @tester = FFakerTW::IdentificationESCL
+  end
+
+  def test_rut
+    assert_match(/\b\d{7,8}-[k|0-9]/i, @tester.rut)
+  end
+end

data/test/test_identification_es_mx.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestIdentificationMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationMX,
+    :rfc_persona_moral, :rfc_persona_fisica, :curp
+  )
+
+  def test_rfc_persona_moral
+    re = /\A[a-zñÑ&]{3}\d{2}[0-1][0-9][0-3][0-9][a-z0-9]{3}\z/i
+    assert_match(re, FFakerTW::IdentificationMX.rfc_persona_moral)
+  end
+
+  def test_rfc_persona_fisica
+    re = /\A[a-zñÑ]{4}\d{2}[0-1][0-9][0-3][0-9][a-z0-9]{3}\z/i
+    assert_match(re, FFakerTW::IdentificationMX.rfc_persona_fisica)
+  end
+
+  def test_curp
+    or_curp_states_abbr = FFakerTW::IdentificationMX::ESTADOS_CURP.join('|')
+    re = /\A[a-z][aeioux][a-z]{2}\d{2}[0-1]\d[0-3]\d[hm](?:#{or_curp_states_abbr})[bcdfghjklmnñpqrstvwxyz]{3}[0-9a-z]\d\z/ui
+    assert_match(re, FFakerTW::IdentificationMX.curp)
+  end
+end

data/test/test_identification_in.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestIdentificationIN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationIN,
+    :aadhaar
+  )
+
+  def setup
+    @tester = FFakerTW::IdentificationIN
+  end
+
+  def test_aadhaar
+    assert_match(/\A\d{12}\z/, @tester.aadhaar)
+  end
+end

data/test/test_identification_it.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationIT,
+    :drivers_license, :ssn, :gender, :ethnicity
+  )
+
+  def setup
+    @tester = FFakerTW::IdentificationIT
+  end
+
+  def test_drivers_license
+    drivers_license_regex = /\AU1[1-9]\d{7}[A-Z]\z/
+    assert_match(drivers_license_regex, @tester.drivers_license)
+  end
+
+  def test_ssn
+    assert_match(/\A\d{20}\z/, @tester.ssn)
+  end
+
+  def test_gender
+    assert_match(/\A(Maschio|Femmina)\z/, @tester.gender)
+  end
+
+  def test_ethnicity
+    ethnicity_regex = %r{\A(Afroamericano|Asiatico/isolano del Pacifico|Caucasico|Ispanico|Nativo americano|Multirazziale|Altro|Preferisco non rispondere)\z}
+    assert_match(ethnicity_regex, @tester.ethnicity)
+  end
+end

data/test/test_identification_kr.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationKr < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::IdentificationKr, :rrn)
+
+  def setup
+    @tester = FFakerTW::IdentificationKr
+  end
+
+  def test_rrn
+    assert_match(/\A\d{6}-\d{7}\z/, @tester.rrn)
+  end
+end

data/test/test_identification_pl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::IdentificationPL,
+    :pesel, :identity_card, :drivers_license
+  )
+
+  def setup
+    @tester = FFakerTW::IdentificationPL
+  end
+
+  def test_pesel
+    assert_match(/\A\d{11}\z/, @tester.pesel)
+  end
+
+  def test_identity_card
+    assert_match(/\A[A-Z]{3}\d{6}\z/, @tester.identity_card)
+  end
+
+  def test_drivers_license
+    assert_match(%r{\A\d{5}/\d{2}/\d{4}\z}, @tester.drivers_license)
+  end
+end

data/test/test_identification_tw.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationTW < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::IdentificationTW, :id)
+
+  def setup
+    @tester = FFakerTW::IdentificationTW
+  end
+
+  def test_id
+    assert_match(/\A[A-Z][12]\d{8}\z/, @tester.id)
+  end
+end

data/test/test_image.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestImage < Test::Unit::TestCase
+  include DeterministicHelper
+
+  PLACEHOLDER = 'https://dummyimage.com/'
+
+  assert_methods_are_deterministic(FFakerTW::Image, :url)
+
+  def setup
+    @tester = FFakerTW::Image
+  end
+
+  def test_url
+    assert_match(%r(#{Regexp.quote(PLACEHOLDER)}300x300/[0-9a-f]{6}/[0-9a-f]{6}\.png\?text=),
+                 @tester.url)
+  end
+
+  def test_image_url_with_param
+    assert_equal("#{PLACEHOLDER}300x300//.png?text=",
+                 @tester.url('300x300', 'png', nil, nil))
+  end
+
+  def test_image_url_with_correct_size
+    assert_match(%r(#{Regexp.quote(PLACEHOLDER)}150x320/[0-9a-f]{6}/[0-9a-f]{6}\.png\?text=),
+                 @tester.url('150x320'))
+  end
+
+  def test_image_url_with_incorrect_size
+    assert_raise ArgumentError do
+      @tester.url('150x320z')
+    end
+  end
+
+  def test_image_url_with_supported_format
+    assert_match(%r(#{Regexp.quote(PLACEHOLDER)}300x300/[0-9a-f]{6}/[0-9a-f]{6}\.jpg\?text=),
+                 @tester.url('300x300', 'jpg'))
+  end
+
+  def test_image_url_with_incorrect_format
+    assert_raise ArgumentError do
+      @tester.url('300x300', 'wrong_format')
+    end
+  end
+
+  def test_image_file
+    assert_equal(@tester.file.class.name, 'File')
+  end
+end