nano-fast-sys 0.0.1

data/ffaker-2.25.0/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(
+    FFaker::IdentificationBR,
+    :cpf, :pretty_cpf, :cnpj, :pretty_cnpj, :rg, :pretty_rg, :gender
+  )
+
+  def setup
+    @tester = FFaker::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/ffaker-2.25.0/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(
+    FFaker::IdentificationESCO,
+    :drivers_license, :driver_license_category, :blood_type, :expedition_date
+  )
+
+  def setup
+    @tester = FFaker::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/ffaker-2.25.0/test/test_identification_ec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestIdentificationEC < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::IdentificationEC, :ci)
+
+  def setup
+    @tester = FFaker::IdentificationEC
+  end
+
+  def test_ci
+    assert_match(/^[0-9]{10}$/, @tester.ci)
+  end
+
+  def test_last_digit
+    ci = @tester.ci
+    sum = 0
+    ci[0..8].chars.each_with_index do |char, index|
+      if index.even?
+        multiple = char.to_i * 2
+        sum += multiple > 9 ? multiple - 9 : multiple
+      else
+        sum += char.to_i
+      end
+    end
+    mod = sum % 10
+    mod = 10 - mod if mod.positive?
+    assert(ci[9].to_i == mod)
+  end
+end

data/ffaker-2.25.0/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(FFaker::IdentificationES, :gender)
+
+  def setup
+    @tester = FFaker::IdentificationES
+  end
+
+  def test_gender
+    assert_match(/(Hombre|Mujer)/, @tester.gender)
+  end
+end

data/ffaker-2.25.0/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(FFaker::IdentificationESCL, :rut)
+
+  def setup
+    @tester = FFaker::IdentificationESCL
+  end
+
+  def test_rut
+    assert_match(/\b\d{7,8}-[k|0-9]/i, @tester.rut)
+  end
+end

data/ffaker-2.25.0/test/test_identification_es_mx.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestIdentificationMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::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, FFaker::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, FFaker::IdentificationMX.rfc_persona_fisica)
+  end
+
+  def test_curp
+    or_curp_states_abbr = FFaker::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})[bcdfghjklmñpqrstvwxyz]{3}[0-9a-z]\d\z
+    /uix
+    assert_match(re, FFaker::IdentificationMX.curp)
+  end
+end

data/ffaker-2.25.0/test/test_identification_fi.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationFI < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::IdentificationFI,
+    :identity_number
+  )
+
+  def setup
+    @tester = FFaker::IdentificationFI
+  end
+
+  def test_identity_number
+    general_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(general_regex, @tester.identity_number)
+    random_far_past_date = rand(Date.civil(1700)..Date.civil(1800))
+    assert_raises ArgumentError do
+      @tester.identity_number(birthday: random_far_past_date)
+    end
+    random_far_future_date = rand(Date.civil(2100)..Date.civil(2200))
+    assert_raises ArgumentError do
+      @tester.identity_number(birthday: random_far_future_date)
+    end
+    date_match_regex = /^010100A(\d\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(date_match_regex, @tester.identity_number(birthday: Date.civil(2000, 1, 1)))
+    fake_number_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])9(\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(fake_number_match_regex, @tester.identity_number(fake: true))
+    real_number_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])([0-8])(\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(real_number_match_regex, @tester.identity_number(fake: false))
+    female_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d)([02468])([0-9A-FHJ-NPR-Y])$/
+    assert_match(female_match_regex, @tester.identity_number(gender: 'female'))
+    male_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d)([13579])([0-9A-FHJ-NPR-Y])$/
+    assert_match(male_match_regex, @tester.identity_number(gender: 'male'))
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::IdentificationIN,
+    :aadhaar
+  )
+
+  def setup
+    @tester = FFaker::IdentificationIN
+  end
+
+  def test_aadhaar
+    assert_match(/\A\d{12}\z/, @tester.aadhaar)
+  end
+end

data/ffaker-2.25.0/test/test_identification_it.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::IdentificationIT,
+    :drivers_license, :ssn, :gender, :ethnicity
+  )
+
+  def setup
+    @tester = FFaker::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
+    }x
+    assert_match(ethnicity_regex, @tester.ethnicity)
+  end
+end

data/ffaker-2.25.0/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(FFaker::IdentificationKR, :rrn)
+
+  def setup
+    @tester = FFaker::IdentificationKR
+  end
+
+  def test_rrn
+    assert_match(/\A\d{6}-\d{7}\z/, @tester.rrn)
+  end
+end

data/ffaker-2.25.0/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(
+    FFaker::IdentificationPL,
+    :pesel, :identity_card, :drivers_license
+  )
+
+  def setup
+    @tester = FFaker::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/ffaker-2.25.0/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(FFaker::IdentificationTW, :id)
+
+  def setup
+    @tester = FFaker::IdentificationTW
+  end
+
+  def test_id
+    assert_match(/\A[A-Z][12]\d{8}\z/, @tester.id)
+  end
+end

data/ffaker-2.25.0/test/test_image.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestImage < Test::Unit::TestCase
+  include DeterministicHelper
+
+  PLACEHOLDER = 'https://dummyimage.com/'
+
+  assert_methods_are_deterministic(FFaker::Image, :url)
+
+  def setup
+    @tester = FFaker::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_url_output_with_keyword_arguments
+    output = capture_output do
+      @tester.url(format: 'jpg')
+    end
+
+    assert_equal ['', ''], output
+  end
+
+  def test_url_with_size_as_positional_argument
+    assert_match(%r(#{Regexp.quote(PLACEHOLDER)}150x320/[0-9a-f]{6}/[0-9a-f]{6}\.png\?text=), @tester.url('150x320'))
+  end
+
+  def test_url_output_with_positional_arguments
+    output = capture_output do
+      @tester.url('150x320')
+    end
+
+    assert_equal(
+      ['', "Positional arguments for Image#url are deprecated. Please use keyword arguments.\n"],
+      output
+    )
+  end
+
+  def test_image_url_with_param
+    assert_equal("#{PLACEHOLDER}300x300//.png?text=",
+                 @tester.url(size: '300x300', format: 'png', bg_color: nil, text_color: 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(size: '150x320'))
+  end
+
+  def test_image_url_with_incorrect_size
+    assert_raise ArgumentError do
+      @tester.url(size: '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(size: '300x300', format: 'jpg'))
+  end
+
+  def test_image_url_with_incorrect_format
+    assert_raise ArgumentError do
+      @tester.url(size: '300x300', format: 'wrong_format')
+    end
+  end
+
+  def test_image_file
+    assert_equal(@tester.file.class.name, 'File')
+  end
+
+  def test_file_output_with_keyword_arguments
+    output = capture_output do
+      @tester.file(format: 'jpg')
+    end
+
+    assert_equal ['', ''], output
+  end
+
+  def test_file_with_size_as_positional_argument
+    assert_equal(@tester.file('150x320').class.name, 'File')
+  end
+
+  def test_file_output_with_positional_arguments
+    output = capture_output do
+      @tester.file('150x320')
+    end
+
+    assert_equal(
+      ['', "Positional arguments for Image#file are deprecated. Please use keyword arguments.\n"],
+      output
+    )
+  end
+end

data/ffaker-2.25.0/test/test_internet.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerInternet < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::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 = FFaker::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/ffaker-2.25.0/test/test_internet_se.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerInternetSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::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 = FFaker::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