ffakerTW 0.1.0

data/test/test_internet.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerInternet < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Internet,
+    :email, :free_email, :safe_email, :disposable_email,
+    :user_name, :domain_name, :domain_word, :domain_suffix,
+    :http_url, :ip_v4_address, :password, :slug, :mac
+  )
+
+  def setup
+    @tester = FFakerTW::Internet
+  end
+
+  def test_email
+    assert @tester.email.match(/.+@.+\.\w+/)
+  end
+
+  def test_email_frozen
+    assert @tester.email.frozen? == false
+  end
+
+  def test_free_email
+    assert @tester.free_email.match(/.+@(gmail|hotmail|yahoo)\.com/)
+  end
+
+  def test_disposable_email
+    assert @tester.disposable_email.match(/.+@(mailinator\.com|suremail\.info|spamherelots\.com|binkmail\.com|safetymail\.info)/)
+  end
+
+  def test_safe_email
+    assert @tester.safe_email.match(/.+@example.(com|net|org)/)
+  end
+
+  def test_user_name
+    assert @tester.user_name.match(/[a-z]+((_|\.)[a-z]+)?/)
+  end
+
+  def test_user_name_with_arg
+    assert @tester.user_name('bo peep').match(/(bo(_|\.)peep|peep(_|\.)bo)/)
+  end
+
+  def test_domain_name
+    assert @tester.domain_name.match(/\w+\.\w+/)
+  end
+
+  def test_domain_word
+    assert @tester.domain_word.match(/^\w+$/)
+  end
+
+  def test_domain_suffix
+    assert @tester.domain_suffix.match(/^\w+(\.\w+)?/)
+  end
+
+  def test_uri
+    assert @tester.uri('ftp').match(%r{^ftp://.+})
+    assert @tester.uri('http').match(%r{^http://.+})
+    assert @tester.uri('https').match(%r{^https://.+})
+
+    assert_deterministic { @tester.uri('ftp') }
+    assert_deterministic { @tester.uri('http') }
+    assert_deterministic { @tester.uri('https') }
+  end
+
+  def test_http_url
+    assert @tester.http_url.match(%r{^http://.+})
+  end
+
+  def test_ip_v4_address
+    assert_match(/\A(?:\d{1,3}\.){3}\d{1,3}\z/, @tester.ip_v4_address)
+  end
+
+  def test_slug
+    assert_match(/\A[a-z]+[_.-][a-z]+\z/, @tester.slug)
+  end
+
+  def test_slug_with_input_words
+    assert_not_match(/&/, @tester.slug('Input Words&&Symbols'))
+    assert_deterministic { @tester.slug('Input Words&&Symbols') }
+  end
+
+  def test_slug_with_specified_glue
+    assert_match(/\A[a-z]+-[a-z]+\z/, @tester.slug(nil, '-'))
+    assert_deterministic { @tester.slug(nil, '-') }
+  end
+
+  def test_password
+    assert_match(/\A\w+\z/, @tester.password)
+  end
+
+  def test_password_min_length
+    assert_greater_than @tester.password(3).length, 2
+    assert_greater_than @tester.password(6).length, 5
+    assert_greater_than @tester.password(15).length, 14
+  end
+
+  def test_password_max_length
+    assert_less_than @tester.password(3, 10).length, 11
+    assert_less_than @tester.password(7, 15).length, 16
+    assert_less_than @tester.password(1, 3).length, 4
+  end
+
+  def test_password_fixed_length
+    assert @tester.password(20, 20).length == 20
+  end
+
+  def test_password_strange_argument
+    assert_greater_than @tester.password(10, 2).length, 9
+    assert_greater_than @tester.password(3, 1).length, 2
+    assert_greater_than @tester.password(8, 5).length, 7
+  end
+
+  def test_mac
+    assert_match(/\A([a-z0-9]{2}:){5}[a-z0-9]{2}\z/, @tester.mac)
+    assert @tester.mac.length == 17
+  end
+
+  def test_mac_delimiter_argument
+    assert_match(/\A([a-z0-9]{2}-){5}[a-z0-9]{2}\z/, @tester.mac('-'))
+    assert_match(/\A([a-z0-9]{2}\.){5}[a-z0-9]{2}\z/, @tester.mac('.'))
+    assert_match(/\A([a-z0-9]{2}){6}\z/, @tester.mac(nil))
+    assert_match(/\A([a-z0-9]{2}){6}\z/, @tester.mac(''))
+    assert @tester.mac('-').length == 17
+    assert @tester.mac('.').length == 17
+    assert @tester.mac(nil).length == 12
+    assert @tester.mac('').length == 12
+  end
+end

data/test/test_internet_se.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerInternetSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::InternetSE,
+    :email, :free_email, :safe_email, :disposable_email,
+    :user_name, :domain_name, :domain_word, :domain_suffix,
+    :http_url, :ip_v4_address, :password, :slug
+  )
+
+  def setup
+    @tester = FFakerTW::InternetSE
+  end
+
+  def test_email
+    assert @tester.email.match(/.+@.+\.\w+/)
+  end
+
+  def test_email_frozen
+    assert @tester.email.frozen? == false
+  end
+
+  def test_disposable_email
+    assert @tester.disposable_email.match(/.+@(mailinator\.com|suremail\.info|spamherelots\.com|binkmail\.com|safetymail\.info)/)
+  end
+
+  def test_free_email
+    email = @tester.free_email
+    assert email.match(/.+@(gmail\.com|hotmail\.com|yahoo\.com|spray\.se|passagen\.se)/), "mail: #{email} does not match"
+  end
+
+  def test_login_user_name
+    assert @tester.login_user_name.match(/[a-z]+((_|)[a-z]+)?/)
+  end
+
+  def test_user_name
+    assert @tester.user_name.match(/[a-z]+((_|\.)[a-z]+)?/)
+  end
+
+  def test_user_name_with_arg
+    assert @tester.user_name('joel larsson').match(/(joel(_|\.)larsson|larsson(_|\.)joel)/)
+    assert_deterministic { @tester.user_name('joel larsson') }
+  end
+
+  def test_domain_name
+    assert @tester.domain_name.match(/\w+\.\w+/)
+  end
+
+  def test_domain_word
+    assert @tester.domain_word.match(/^\w+$/)
+  end
+
+  def test_domain_suffix
+    assert @tester.domain_suffix.match(/^\w+(\.\w+)?/)
+  end
+
+  def test_uri
+    assert @tester.uri('ftp').match(%r{^ftp://.+})
+    assert @tester.uri('http').match(%r{^http://.+})
+    assert @tester.uri('https').match(%r{^https://.+})
+  end
+
+  def test_http_url
+    assert @tester.http_url.match(%r{^http://.+})
+  end
+
+  def test_ip_v4_address
+    assert @tester.ip_v4_address.match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/)
+  end
+
+  def test_slug
+    assert @tester.slug.match(/^[a-z]+(_|\.|-)[a-z]+$/)
+  end
+end

data/test/test_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJob < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Job, :title)
+
+  def setup
+    @tester = FFakerTW::Job
+  end
+
+  def test_title
+    assert_match(/\A(\w+\.? ?){2,3}\z/, @tester.title)
+  end
+end

data/test/test_job_br.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobBR, :title)
+
+  def setup
+    @tester = FFakerTW::JobBR
+  end
+
+  def test_title
+    assert_includes @tester::JOB_NOUNS, @tester.title
+  end
+end

data/test/test_job_cn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobCN, :title)
+
+  def setup
+    @tester = FFakerTW::JobCN
+  end
+
+  def test_title
+    assert_greater_than_or_equal_to @tester.title.length, 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_job_fr.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobFr < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobFR, :title)
+
+  def setup
+    @tester = FFakerTW::JobFR
+  end
+
+  def test_title
+    assert_match(/\A([a-zàâçéèêëîïôûùüÿñæœ]+\.? ?){2,}\z/, @tester.title)
+  end
+
+  def test_prefix
+    assert_kind_of Array, @tester::JOB_PREFIXES
+    assert_kind_of Array, @tester::JOB_ADJECTIVES
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_job_it.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobIT, :title)
+
+  def setup
+    @tester = FFakerTW::JobIT
+  end
+
+  def test_title
+    assert_match(/\A(\w+\.? ?){2,3}\z/, @tester.title)
+  end
+end

data/test/test_job_ja.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobJA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobJA, :title)
+
+  def setup
+    @tester = FFakerTW::JobJA
+  end
+
+  def test_title
+    assert_greater_than_or_equal_to @tester.title.length, 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_job_kr.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobKR, :title)
+
+  def setup
+    @tester = FFakerTW::JobKR
+  end
+
+  def test_title
+    assert_greater_than_or_equal_to @tester.title.length, 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_job_vn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobVN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::JobVN, :title)
+
+  def setup
+    @tester = FFakerTW::JobVN
+  end
+
+  def test_title
+    assert_greater_than_or_equal_to @tester.title.length, 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_locale.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLocale < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Locale, :code, :language)
+
+  def test_code
+    assert_match(/./, FFakerTW::Locale.code)
+  end
+
+  def test_language
+    assert_match(/./, FFakerTW::Locale.language)
+  end
+
+  def test_language_with_args
+    assert_match('French', FFakerTW::Locale.language('FR'))
+    assert_deterministic { FFakerTW::Locale.language('FR') }
+  end
+
+  def test_code_with_args
+    assert_match('FR', FFakerTW::Locale.code('French'))
+    assert_deterministic { FFakerTW::Locale.code('French') }
+  end
+end

data/test/test_lorem.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLorem < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Lorem,
+    :paragraph, :sentence, :phrase, :paragraphs, :sentences, :phrases, :words, :word, :characters
+  )
+
+  def test_paragraph
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.paragraph)
+  end
+
+  def test_sentence
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.sentence)
+    assert_nothing_thrown do
+      100.times { FFakerTW::Lorem.sentence 0 }
+    end
+  end
+
+  def test_phrase
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.phrase)
+  end
+
+  def test_paragraphs
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.sentences.join(' '))
+  end
+
+  def test_phrases
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.phrases.join(' '))
+  end
+
+  def test_words
+    assert_match(/[ a-z]+/, FFakerTW::Lorem.words.join(' '))
+  end
+
+  def test_word
+    assert_match(/[a-z]+/, FFakerTW::Lorem.word)
+  end
+
+  def test_characters
+    assert_match(/[a-z0-9]+/, FFakerTW::Lorem.characters)
+    assert FFakerTW::Lorem.characters.length == 255
+    assert FFakerTW::Lorem.characters(10).length == 10
+    assert FFakerTW::Lorem.characters(-1) == ''
+  end
+
+  def test_word_collection_uniqueness
+    assert_equal(FFakerTW::Lorem::WORDS, FFakerTW::Lorem::WORDS.uniq)
+  end
+end

data/test/test_lorem_ar.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLoremARAR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::LoremAR,
+    :paragraph, :paragraphs, :sentence, :sentences, :phrase, :phrases, :word, :words
+  )
+
+  def test_paragraph
+    assert_match(/[ a-z]+/, FFakerTW::LoremAR.paragraph)
+  end
+
+  def test_sentence
+    assert_match(/[ a-z]+/, FFakerTW::LoremAR.sentence)
+  end
+
+  def test_phrase
+    assert_match(/[ a-z]+/, FFakerTW::LoremAR.phrase)
+  end
+
+  def test_paragraphs
+    assert_match(/[^a-zA-Z0-9]+/, FFakerTW::LoremAR.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(/[^a-zA-Z0-9]+/, FFakerTW::LoremAR.sentences.join(' '))
+  end
+
+  def test_phrases
+    assert_match(/[^a-zA-Z0-9]+/, FFakerTW::LoremAR.phrases.join(' '))
+  end
+
+  def test_words
+    assert_match(/[^a-zA-Z0-9]+/, FFakerTW::LoremAR.words.join(' '))
+  end
+
+  def test_word
+    assert_match(/[^a-zA-Z0-9]+/, FFakerTW::LoremAR.word)
+  end
+end

data/test/test_lorem_br.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLoremBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::LoremBR,
+    :paragraph, :sentence, :phrase, :paragraphs, :sentences, :phrases, :words, :word, :characters
+  )
+
+  CHARACTERS = /\A[A-zÀ-ü0-9]+\z/i 
+  WORD = /\A[A-zÀ-ü-]+\z/i
+  WORDS = /[ A-zÀ-ü-.]+/i
+
+  def test_paragraph
+    assert_match(WORDS, FFakerTW::LoremBR.paragraph)
+  end
+
+  def test_sentence
+    assert_match(WORDS, FFakerTW::LoremBR.sentence)
+    assert_nothing_thrown do
+      100.times { FFakerTW::LoremBR.sentence 0 }
+    end
+  end
+
+  def test_phrase
+    assert_match(WORDS, FFakerTW::LoremBR.phrase)
+  end
+
+  def test_paragraphs
+    assert_match(WORDS, FFakerTW::LoremBR.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(WORDS, FFakerTW::LoremBR.sentences.join(' '))
+  end
+
+  def test_phrases
+    assert_match(WORDS, FFakerTW::LoremBR.phrases.join(' '))
+  end
+
+  def test_words
+    assert_match(WORDS, FFakerTW::LoremBR.words.join(' '))
+  end
+
+  def test_word
+    assert_match(WORD, FFakerTW::LoremBR.word)
+  end
+
+  def test_characters
+    assert_match(CHARACTERS, FFakerTW::LoremBR.characters)
+    assert FFakerTW::LoremBR.characters.length == 255
+    assert FFakerTW::LoremBR.characters(10).length == 10
+    assert FFakerTW::LoremBR.characters(-1) == ''
+  end
+
+  def test_word_collection_uniqueness
+    assert_equal(FFakerTW::Lorem::WORDS, FFakerTW::Lorem::WORDS.uniq)
+  end
+end

data/test/test_lorem_cn.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLoremCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::LoremCN,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
+  def test_paragraph
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.paragraph.length, 3 * 4 * 2
+  end
+
+  def test_sentence
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.sentence.length, 4 * 2
+  end
+
+  def test_paragraphs
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.paragraphs.length, 2
+  end
+
+  def test_paragraphs_is_not_a_string_representation_of_an_array
+    assert !/[\[\]]+/.match([FFakerTW::LoremCN.paragraphs].flatten.join(' '))
+  end
+
+  def test_paragraphs_is_an_array
+    assert FFakerTW::LoremCN.paragraphs.class == Array
+  end
+
+  def test_sentences
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.sentences.length, 2
+  end
+
+  def test_sentences_is_an_array
+    assert FFakerTW::LoremCN.sentences.class == Array
+  end
+
+  def test_sentences_via_to_s_produces_string_terminated_with_period
+    string = FFakerTW::LoremCN.sentences.to_s
+    assert string.class == String
+    assert string =~ /。$/
+  end
+
+  def test_words
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.words.length, 2
+  end
+
+  def test_word
+    assert_greater_than_or_equal_to FFakerTW::LoremCN.word.length, 1
+  end
+end

data/test/test_lorem_fr.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLoremFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::LoremFR,
+    :paragraph, :paragraphs, :sentence, :sentences, :phrase, :phrases, :word, :words
+  )
+
+  REGEX = /\A[ -.ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
+  REGEX_WORD = /\A[-ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
+  REGEX_WORDS = /\A[ -ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
+
+  def test_paragraph
+    assert_match(REGEX, FFakerTW::LoremFR.paragraph)
+  end
+
+  def test_sentence
+    assert_match(REGEX, FFakerTW::LoremFR.sentence)
+  end
+
+  def test_phrase
+    assert_match(REGEX, FFakerTW::LoremFR.phrase)
+  end
+
+  def test_paragraphs
+    assert_match(REGEX, FFakerTW::LoremFR.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(REGEX, FFakerTW::LoremFR.sentences.join(' '))
+  end
+
+  def test_phrases
+    assert_match(REGEX, FFakerTW::LoremFR.phrases.join(' '))
+  end
+
+  def test_words
+    assert_match(REGEX_WORDS, FFakerTW::LoremFR.words.join(' '))
+  end
+
+  def test_word
+    assert_match(REGEX_WORD, FFakerTW::LoremFR.word)
+  end
+end