repo stringlengths 5 92 | file_url stringlengths 80 287 | file_path stringlengths 5 197 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:37:27 2026-01-04 17:58:21 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/tables.rb | lib/pghero/methods/tables.rb | module PgHero
module Methods
module Tables
def table_hit_rate
select_one <<~SQL
SELECT
sum(heap_blks_hit) / nullif(sum(heap_blks_hit) + sum(heap_blks_read), 0) AS rate
FROM
pg_statio_user_tables
SQL
end
def table_caching
select_all <<~SQL
SELECT
schemaname AS schema,
relname AS table,
CASE WHEN heap_blks_hit + heap_blks_read = 0 THEN
0
ELSE
ROUND(1.0 * heap_blks_hit / (heap_blks_hit + heap_blks_read), 2)
END AS hit_rate
FROM
pg_statio_user_tables
ORDER BY
2 DESC, 1
SQL
end
def unused_tables
select_all <<~SQL
SELECT
schemaname AS schema,
relname AS table,
n_live_tup AS estimated_rows
FROM
pg_stat_user_tables
WHERE
idx_scan = 0
ORDER BY
n_live_tup DESC,
relname ASC
SQL
end
def table_stats(schema: nil, table: nil)
select_all <<~SQL
SELECT
nspname AS schema,
relname AS table,
reltuples::bigint AS estimated_rows,
pg_total_relation_size(pg_class.oid) AS size_bytes
FROM
pg_class
INNER JOIN
pg_namespace ON pg_namespace.oid = pg_class.relnamespace
WHERE
relkind = 'r'
#{schema ? "AND nspname = #{quote(schema)}" : nil}
#{table ? "AND relname IN (#{Array(table).map { |t| quote(t) }.join(", ")})" : nil}
ORDER BY
1, 2
SQL
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/system.rb | lib/pghero/methods/system.rb | module PgHero
module Methods
module System
def system_stats_enabled?
!system_stats_provider.nil?
end
def system_stats_provider
if aws_db_instance_identifier
:aws
elsif gcp_database_id
:gcp
elsif azure_resource_id
:azure
end
end
def cpu_usage(**options)
system_stats(:cpu, **options)
end
def connection_stats(**options)
system_stats(:connections, **options)
end
def replication_lag_stats(**options)
system_stats(:replication_lag, **options)
end
def read_iops_stats(**options)
system_stats(:read_iops, **options)
end
def write_iops_stats(**options)
system_stats(:write_iops, **options)
end
def free_space_stats(**options)
system_stats(:free_space, **options)
end
def rds_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
if system_stats_enabled?
aws_options = {region: aws_region}
if aws_access_key_id
aws_options[:access_key_id] = aws_access_key_id
aws_options[:secret_access_key] = aws_secret_access_key
end
client = Aws::CloudWatch::Client.new(aws_options)
duration = (duration || 1.hour).to_i
period = (period || 1.minute).to_i
offset = (offset || 0).to_i
end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
start_time = end_time - duration
resp = client.get_metric_statistics(
namespace: "AWS/RDS",
metric_name: metric_name,
dimensions: [{name: "DBInstanceIdentifier", value: aws_db_instance_identifier}],
start_time: start_time.iso8601,
end_time: end_time.iso8601,
period: period,
statistics: ["Average"]
)
data = {}
resp[:datapoints].sort_by { |d| d[:timestamp] }.each do |d|
data[d[:timestamp]] = d[:average]
end
add_missing_data(data, start_time, end_time, period) if series
data
else
raise NotEnabled, "System stats not enabled"
end
end
def azure_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
# TODO DRY with RDS stats
duration = (duration || 1.hour).to_i
period = (period || 1.minute).to_i
offset = (offset || 0).to_i
end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
start_time = end_time - duration
interval =
case period
when 60
"PT1M"
when 300
"PT5M"
when 900
"PT15M"
when 1800
"PT30M"
when 3600
"PT1H"
else
raise Error, "Unsupported period"
end
client = Azure::Monitor::Profiles::Latest::Mgmt::Client.new
# call utc to convert +00:00 to Z
timespan = "#{start_time.utc.iso8601}/#{end_time.utc.iso8601}"
results = client.metrics.list(
azure_resource_id,
metricnames: metric_name,
aggregation: "Average",
timespan: timespan,
interval: interval
)
data = {}
result = results.value.first
if result
result.timeseries.first.data.each do |point|
data[point.time_stamp.to_time] = point.average
end
end
add_missing_data(data, start_time, end_time, period) if series
data
end
private
def gcp_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
# TODO DRY with RDS stats
duration = (duration || 1.hour).to_i
period = (period || 1.minute).to_i
offset = (offset || 0).to_i
end_time = Time.at(((Time.now - offset).to_f / period).ceil * period)
start_time = end_time - duration
# validate input since we need to interpolate below
raise Error, "Invalid metric name" unless /\A[a-z\/_]+\z/i.match?(metric_name)
raise Error, "Invalid database id" unless /\A[a-z0-9\-:]+\z/i.match?(gcp_database_id)
# we handle four situations:
# 1. google-cloud-monitoring-v3
# 2. google-cloud-monitoring >= 1
# 3. google-cloud-monitoring < 1
# 4. google-apis-monitoring_v3
begin
require "google/cloud/monitoring/v3"
rescue LoadError
begin
require "google/cloud/monitoring"
rescue LoadError
require "google/apis/monitoring_v3"
end
end
# for situations 1 and 2
# Google::Cloud::Monitoring.metric_service is documented
# but doesn't work for situation 1
if defined?(Google::Cloud::Monitoring::V3::MetricService::Client)
client = Google::Cloud::Monitoring::V3::MetricService::Client.new
interval = Google::Cloud::Monitoring::V3::TimeInterval.new
interval.end_time = Google::Protobuf::Timestamp.new(seconds: end_time.to_i)
# subtract period to make sure we get first data point
interval.start_time = Google::Protobuf::Timestamp.new(seconds: (start_time - period).to_i)
aggregation = Google::Cloud::Monitoring::V3::Aggregation.new
# may be better to use ALIGN_NEXT_OLDER for space stats to show most recent data point
# stick with average for now to match AWS
aggregation.per_series_aligner = Google::Cloud::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN
aggregation.alignment_period = period
results = client.list_time_series({
name: "projects/#{gcp_database_id.split(":").first}",
filter: "metric.type = \"cloudsql.googleapis.com/database/#{metric_name}\" AND resource.label.database_id = \"#{gcp_database_id}\"",
interval: interval,
view: Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL,
aggregation: aggregation
})
elsif defined?(Google::Cloud::Monitoring)
require "google/cloud/monitoring"
client = Google::Cloud::Monitoring::Metric.new
interval = Google::Monitoring::V3::TimeInterval.new
interval.end_time = Google::Protobuf::Timestamp.new(seconds: end_time.to_i)
# subtract period to make sure we get first data point
interval.start_time = Google::Protobuf::Timestamp.new(seconds: (start_time - period).to_i)
aggregation = Google::Monitoring::V3::Aggregation.new
# may be better to use ALIGN_NEXT_OLDER for space stats to show most recent data point
# stick with average for now to match AWS
aggregation.per_series_aligner = Google::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN
aggregation.alignment_period = period
results = client.list_time_series(
"projects/#{gcp_database_id.split(":").first}",
"metric.type = \"cloudsql.googleapis.com/database/#{metric_name}\" AND resource.label.database_id = \"#{gcp_database_id}\"",
interval,
Google::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL,
aggregation: aggregation
)
else
client = Google::Apis::MonitoringV3::MonitoringService.new
scope = Google::Apis::MonitoringV3::AUTH_MONITORING_READ
client.authorization = Google::Auth.get_application_default([scope])
# default logging is very verbose, but use app default
results = client.list_project_time_series(
"projects/#{gcp_database_id.split(":").first}",
filter: "metric.type = \"cloudsql.googleapis.com/database/#{metric_name}\" AND resource.label.database_id = \"#{gcp_database_id}\"",
interval_start_time: (start_time - period).iso8601,
interval_end_time: end_time.iso8601,
view: 0, # full
aggregation_alignment_period: "#{period}s",
aggregation_per_series_aligner: 12 # mean
).time_series
end
data = {}
result = results.first
if result
result.points.each do |point|
time = point.interval.start_time
# string with google-apis-monitoring_v3
time = time.is_a?(String) ? Time.parse(time) : Time.at(time.seconds)
value = point.value.double_value
value *= 100 if metric_name == "cpu/utilization"
data[time] = value
end
end
add_missing_data(data, start_time, end_time, period) if series
data
end
def system_stats(metric_key, **options)
case system_stats_provider
when :aws
metrics = {
cpu: "CPUUtilization",
connections: "DatabaseConnections",
replication_lag: "ReplicaLag",
read_iops: "ReadIOPS",
write_iops: "WriteIOPS",
free_space: "FreeStorageSpace"
}
rds_stats(metrics[metric_key], **options)
when :gcp
if metric_key == :free_space
quota = gcp_stats("disk/quota", **options)
used = gcp_stats("disk/bytes_used", **options)
free_space(quota, used)
else
metrics = {
cpu: "cpu/utilization",
connections: "postgresql/num_backends",
replication_lag: "replication/replica_lag",
read_iops: "disk/read_ops_count",
write_iops: "disk/write_ops_count"
}
gcp_stats(metrics[metric_key], **options)
end
when :azure
if metric_key == :free_space
quota = azure_stats("storage_limit", **options)
used = azure_stats("storage_used", **options)
free_space(quota, used)
else
replication_lag_stat = azure_flexible_server? ? "physical_replication_delay_in_seconds" : "pg_replica_log_delay_in_seconds"
metrics = {
cpu: "cpu_percent",
connections: "active_connections",
replication_lag: replication_lag_stat,
read_iops: "read_iops", # flexible server only
write_iops: "write_iops" # flexible server only
}
raise Error, "Metric not supported" unless metrics[metric_key]
azure_stats(metrics[metric_key], **options)
end
else
raise NotEnabled, "System stats not enabled"
end
end
def azure_flexible_server?
azure_resource_id.include?("/Microsoft.DBforPostgreSQL/flexibleServers/")
end
# only use data points included in both series
# this also eliminates need to align Time.now
def free_space(quota, used)
data = {}
quota.each do |k, v|
data[k] = v - used[k] if v && used[k]
end
data
end
def add_missing_data(data, start_time, end_time, period)
time = start_time
while time < end_time
data[time] ||= nil
time += period
end
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/indexes.rb | lib/pghero/methods/indexes.rb | module PgHero
module Methods
module Indexes
def index_hit_rate
select_one <<~SQL
SELECT
(sum(idx_blks_hit)) / nullif(sum(idx_blks_hit + idx_blks_read), 0) AS rate
FROM
pg_statio_user_indexes
SQL
end
def index_caching
select_all <<~SQL
SELECT
schemaname AS schema,
relname AS table,
indexrelname AS index,
CASE WHEN idx_blks_hit + idx_blks_read = 0 THEN
0
ELSE
ROUND(1.0 * idx_blks_hit / (idx_blks_hit + idx_blks_read), 2)
END AS hit_rate
FROM
pg_statio_user_indexes
ORDER BY
3 DESC, 1
SQL
end
def index_usage
select_all <<~SQL
SELECT
schemaname AS schema,
relname AS table,
CASE idx_scan
WHEN 0 THEN 'Insufficient data'
ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
END percent_of_times_index_used,
n_live_tup AS estimated_rows
FROM
pg_stat_user_tables
ORDER BY
n_live_tup DESC,
relname ASC
SQL
end
def missing_indexes
select_all <<~SQL
SELECT
schemaname AS schema,
relname AS table,
CASE idx_scan
WHEN 0 THEN 'Insufficient data'
ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
END percent_of_times_index_used,
n_live_tup AS estimated_rows
FROM
pg_stat_user_tables
WHERE
idx_scan > 0
AND (100 * idx_scan / (seq_scan + idx_scan)) < 95
AND n_live_tup >= 10000
ORDER BY
n_live_tup DESC,
relname ASC
SQL
end
def unused_indexes(max_scans: 50, across: [])
result = select_all_size <<~SQL
SELECT
schemaname AS schema,
relname AS table,
indexrelname AS index,
pg_relation_size(i.indexrelid) AS size_bytes,
idx_scan as index_scans
FROM
pg_stat_user_indexes ui
INNER JOIN
pg_index i ON ui.indexrelid = i.indexrelid
WHERE
NOT indisunique
AND idx_scan <= #{max_scans.to_i}
ORDER BY
pg_relation_size(i.indexrelid) DESC,
relname ASC
SQL
across.each do |database_id|
database = PgHero.databases.values.find { |d| d.id == database_id }
raise PgHero::Error, "Database not found: #{database_id}" unless database
across_result = Set.new(database.unused_indexes(max_scans: max_scans).map { |v| [v[:schema], v[:index]] })
result.select! { |v| across_result.include?([v[:schema], v[:index]]) }
end
result
end
def reset_stats
execute("SELECT pg_stat_reset()")
true
end
def last_stats_reset_time
select_one <<~SQL
SELECT
pg_stat_get_db_stat_reset_time(oid) AS reset_time
FROM
pg_database
WHERE
datname = current_database()
SQL
end
def invalid_indexes(indexes: nil)
indexes = (indexes || self.indexes).select { |i| !i[:valid] && !i[:creating] }
indexes.each do |index|
# map name -> index for backward compatibility
index[:index] = index[:name]
end
indexes
end
# TODO parse array properly
# https://stackoverflow.com/questions/2204058/list-columns-with-indexes-in-postgresql
def indexes
indexes = select_all(<<~SQL
SELECT
schemaname AS schema,
t.relname AS table,
ix.relname AS name,
regexp_replace(pg_get_indexdef(i.indexrelid), '^[^\\(]*\\((.*)\\)$', '\\1') AS columns,
regexp_replace(pg_get_indexdef(i.indexrelid), '.* USING ([^ ]*) \\(.*', '\\1') AS using,
indisunique AS unique,
indisprimary AS primary,
indisvalid AS valid,
indexprs::text,
indpred::text,
pg_get_indexdef(i.indexrelid) AS definition
FROM
pg_index i
INNER JOIN
pg_class t ON t.oid = i.indrelid
INNER JOIN
pg_class ix ON ix.oid = i.indexrelid
LEFT JOIN
pg_stat_user_indexes ui ON ui.indexrelid = i.indexrelid
WHERE
schemaname IS NOT NULL
ORDER BY
1, 2
SQL
).map { |v| v[:columns] = v[:columns].sub(") WHERE (", " WHERE ").split(", ").map { |c| unquote(c) }; v }
# determine if any invalid indexes being created
# hacky, but works for simple cases
# can be a race condition, but that's fine
invalid_indexes = indexes.select { |i| !i[:valid] }
if invalid_indexes.any?
create_index_queries = running_queries.select { |q| /\s*CREATE\s+INDEX\s+CONCURRENTLY\s+/i.match(q[:query]) }
invalid_indexes.each do |index|
index[:creating] = create_index_queries.any? { |q| q[:query].include?(index[:table]) && index[:columns].all? { |c| q[:query].include?(c) } }
end
end
indexes
end
def duplicate_indexes(indexes: nil)
dup_indexes = []
indexes_by_table = (indexes || self.indexes).group_by { |i| [i[:schema], i[:table]] }
indexes_by_table.values.flatten.select { |i| i[:valid] && !i[:primary] && !i[:unique] }.each do |index|
covering_index = indexes_by_table[[index[:schema], index[:table]]].find { |i| i[:valid] && i[:name] != index[:name] && index_covers?(i[:columns], index[:columns]) && i[:using] == index[:using] && i[:indexprs] == index[:indexprs] && i[:indpred] == index[:indpred] }
if covering_index && (covering_index[:columns] != index[:columns] || index[:name] > covering_index[:name] || covering_index[:primary] || covering_index[:unique])
dup_indexes << {unneeded_index: index, covering_index: covering_index}
end
end
dup_indexes.sort_by { |i| ui = i[:unneeded_index]; [ui[:table], ui[:columns]] }
end
# https://gist.github.com/mbanck/9976015/71888a24e464e2f772182a7eb54f15a125edf398
# thanks @jberkus and @mbanck
def index_bloat(min_size: nil)
min_size ||= index_bloat_bytes
select_all <<~SQL
WITH btree_index_atts AS (
SELECT
nspname, relname, reltuples, relpages, indrelid, relam,
regexp_split_to_table(indkey::text, ' ')::smallint AS attnum,
indexrelid as index_oid
FROM
pg_index
JOIN
pg_class ON pg_class.oid = pg_index.indexrelid
JOIN
pg_namespace ON pg_namespace.oid = pg_class.relnamespace
JOIN
pg_am ON pg_class.relam = pg_am.oid
WHERE
pg_am.amname = 'btree'
),
index_item_sizes AS (
SELECT
i.nspname,
i.relname,
i.reltuples,
i.relpages,
i.relam,
(quote_ident(s.schemaname) || '.' || quote_ident(s.tablename))::regclass AS starelid,
a.attrelid AS table_oid, index_oid,
current_setting('block_size')::numeric AS bs,
/* MAXALIGN: 4 on 32bits, 8 on 64bits (and mingw32 ?) */
CASE
WHEN version() ~ 'mingw32' OR version() ~ '64-bit' THEN 8
ELSE 4
END AS maxalign,
24 AS pagehdr,
/* per tuple header: add index_attribute_bm if some cols are null-able */
CASE WHEN max(coalesce(s.null_frac,0)) = 0
THEN 2
ELSE 6
END AS index_tuple_hdr,
/* data len: we remove null values save space using it fractionnal part from stats */
sum( (1-coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 2048) ) AS nulldatawidth
FROM
pg_attribute AS a
JOIN
pg_stats AS s ON (quote_ident(s.schemaname) || '.' || quote_ident(s.tablename))::regclass=a.attrelid AND s.attname = a.attname
JOIN
btree_index_atts AS i ON i.indrelid = a.attrelid AND a.attnum = i.attnum
WHERE
a.attnum > 0
GROUP BY
1, 2, 3, 4, 5, 6, 7, 8, 9
),
index_aligned AS (
SELECT
maxalign,
bs,
nspname,
relname AS index_name,
reltuples,
relpages,
relam,
table_oid,
index_oid,
( 2 +
maxalign - CASE /* Add padding to the index tuple header to align on MAXALIGN */
WHEN index_tuple_hdr%maxalign = 0 THEN maxalign
ELSE index_tuple_hdr%maxalign
END
+ nulldatawidth + maxalign - CASE /* Add padding to the data to align on MAXALIGN */
WHEN nulldatawidth::integer%maxalign = 0 THEN maxalign
ELSE nulldatawidth::integer%maxalign
END
)::numeric AS nulldatahdrwidth, pagehdr
FROM
index_item_sizes AS s1
),
otta_calc AS (
SELECT
bs,
nspname,
table_oid,
index_oid,
index_name,
relpages,
coalesce(
ceil((reltuples*(4+nulldatahdrwidth))/(bs-pagehdr::float)) +
CASE WHEN am.amname IN ('hash','btree') THEN 1 ELSE 0 END , 0 /* btree and hash have a metadata reserved block */
) AS otta
FROM
index_aligned AS s2
LEFT JOIN
pg_am am ON s2.relam = am.oid
),
raw_bloat AS (
SELECT
nspname,
c.relname AS table_name,
index_name,
bs*(sub.relpages)::bigint AS totalbytes,
CASE
WHEN sub.relpages <= otta THEN 0
ELSE bs*(sub.relpages-otta)::bigint END
AS wastedbytes,
CASE
WHEN sub.relpages <= otta
THEN 0 ELSE bs*(sub.relpages-otta)::bigint * 100 / (bs*(sub.relpages)::bigint) END
AS realbloat,
pg_relation_size(sub.table_oid) as table_bytes,
stat.idx_scan as index_scans,
stat.indexrelid
FROM
otta_calc AS sub
JOIN
pg_class AS c ON c.oid=sub.table_oid
JOIN
pg_stat_user_indexes AS stat ON sub.index_oid = stat.indexrelid
)
SELECT
nspname AS schema,
table_name AS table,
index_name AS index,
wastedbytes AS bloat_bytes,
totalbytes AS index_bytes,
pg_get_indexdef(rb.indexrelid) AS definition,
indisprimary AS primary
FROM
raw_bloat rb
INNER JOIN
pg_index i ON i.indexrelid = rb.indexrelid
WHERE
wastedbytes >= #{min_size.to_i}
ORDER BY
wastedbytes DESC,
index_name
SQL
end
protected
def index_covers?(indexed_columns, columns)
indexed_columns.first(columns.size) == columns
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/replication.rb | lib/pghero/methods/replication.rb | module PgHero
module Methods
module Replication
def replica?
unless defined?(@replica)
@replica = select_one("SELECT pg_is_in_recovery()")
end
@replica
end
# https://www.postgresql.org/message-id/CADKbJJWz9M0swPT3oqe8f9+tfD4-F54uE6Xtkh4nERpVsQnjnw@mail.gmail.com
def replication_lag
with_feature_support(:replication_lag) do
lag_condition =
if server_version_num >= 100000
"pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn()"
else
"pg_last_xlog_receive_location() = pg_last_xlog_replay_location()"
end
select_one <<~SQL
SELECT
CASE
WHEN NOT pg_is_in_recovery() OR #{lag_condition} THEN 0
ELSE EXTRACT (EPOCH FROM NOW() - pg_last_xact_replay_timestamp())
END
AS replication_lag
SQL
end
end
def replication_slots
if server_version_num >= 90400
with_feature_support(:replication_slots, []) do
select_all <<~SQL
SELECT
slot_name,
database,
active
FROM pg_replication_slots
SQL
end
else
[]
end
end
def replicating?
with_feature_support(:replicating?, false) do
select_all("SELECT state FROM pg_stat_replication").any?
end
end
private
def feature_support
@feature_support ||= {}
end
def with_feature_support(cache_key, default = nil)
# cache feature support to minimize errors in logs
return default if feature_support[cache_key] == false
begin
yield
rescue ActiveRecord::StatementInvalid => e
raise unless e.message.start_with?("PG::FeatureNotSupported:")
feature_support[cache_key] = false
default
end
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/space.rb | lib/pghero/methods/space.rb | module PgHero
module Methods
module Space
def database_size
PgHero.pretty_size select_one("SELECT pg_database_size(current_database())")
end
def relation_sizes
select_all_size <<~SQL
SELECT
n.nspname AS schema,
c.relname AS relation,
CASE c.relkind WHEN 'r' THEN 'table' WHEN 'm' then 'matview' ELSE 'index' END AS type,
pg_table_size(c.oid) AS size_bytes
FROM
pg_class c
LEFT JOIN
pg_namespace n ON n.oid = c.relnamespace
WHERE
n.nspname NOT IN ('pg_catalog', 'information_schema')
AND n.nspname !~ '^pg_toast'
AND c.relkind IN ('r', 'm', 'i')
ORDER BY
pg_table_size(c.oid) DESC,
2 ASC
SQL
end
def table_sizes
select_all_size <<~SQL
SELECT
n.nspname AS schema,
c.relname AS table,
pg_total_relation_size(c.oid) AS size_bytes
FROM
pg_class c
LEFT JOIN
pg_namespace n ON n.oid = c.relnamespace
WHERE
n.nspname NOT IN ('pg_catalog', 'information_schema')
AND n.nspname !~ '^pg_toast'
AND c.relkind = 'r'
ORDER BY
pg_total_relation_size(c.oid) DESC,
2 ASC
SQL
end
def space_growth(days: 7, relation_sizes: nil)
if space_stats_enabled?
relation_sizes ||= self.relation_sizes
sizes = relation_sizes.to_h { |r| [[r[:schema], r[:relation]], r[:size_bytes]] }
start_at = days.days.ago
stats = select_all_stats <<~SQL
WITH t AS (
SELECT
schema,
relation,
array_agg(size ORDER BY captured_at) AS sizes
FROM
pghero_space_stats
WHERE
database = #{quote(id)}
AND captured_at >= #{quote(start_at)}
GROUP BY
1, 2
)
SELECT
schema,
relation,
sizes[1] AS size_bytes
FROM
t
ORDER BY
1, 2
SQL
stats.each do |r|
relation = [r[:schema], r[:relation]]
if sizes[relation]
r[:growth_bytes] = sizes[relation] - r[:size_bytes]
end
r.delete(:size_bytes)
end
stats
else
raise NotEnabled, "Space stats not enabled"
end
end
def relation_space_stats(relation, schema: "public")
if space_stats_enabled?
relation_sizes ||= self.relation_sizes
sizes = relation_sizes.map { |r| [[r[:schema], r[:relation]], r[:size_bytes]] }.to_h
start_at = 30.days.ago
stats = select_all_stats <<~SQL
SELECT
captured_at,
size AS size_bytes
FROM
pghero_space_stats
WHERE
database = #{quote(id)}
AND captured_at >= #{quote(start_at)}
AND schema = #{quote(schema)}
AND relation = #{quote(relation)}
ORDER BY
1 ASC
SQL
stats << {
captured_at: Time.now,
size_bytes: sizes[[schema, relation]].to_i
}
else
raise NotEnabled, "Space stats not enabled"
end
end
def capture_space_stats
now = Time.now
values =
relation_sizes.map do |rs|
{
database: id,
schema: rs[:schema],
relation: rs[:relation],
size: rs[:size_bytes].to_i,
captured_at: now
}
end
PgHero::SpaceStats.insert_all!(values) if values.any?
end
def clean_space_stats(before: nil)
before ||= 90.days.ago
PgHero::SpaceStats.where(database: id).where("captured_at < ?", before).delete_all
end
def space_stats_enabled?
table_exists?("pghero_space_stats")
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/query_stats.rb | lib/pghero/methods/query_stats.rb | module PgHero
module Methods
module QueryStats
def query_stats(historical: false, start_at: nil, end_at: nil, min_average_time: nil, min_calls: nil, **options)
current_query_stats = historical && end_at && end_at < Time.now ? [] : current_query_stats(**options)
historical_query_stats = historical && historical_query_stats_enabled? ? historical_query_stats(start_at: start_at, end_at: end_at, **options) : []
query_stats = combine_query_stats((current_query_stats + historical_query_stats).group_by { |q| [q[:query_hash], q[:user]] })
query_stats = combine_query_stats(query_stats.group_by { |q| [normalize_query(q[:query]), q[:user]] })
# add percentages
all_queries_total_minutes = [current_query_stats, historical_query_stats].sum { |s| (s.first || {})[:all_queries_total_minutes] || 0 }
query_stats.each do |query|
query[:average_time] = query[:total_minutes] * 1000 * 60 / query[:calls]
query[:total_percent] = query[:total_minutes] * 100.0 / all_queries_total_minutes
end
sort = options[:sort] || "total_minutes"
query_stats = query_stats.sort_by { |q| -q[sort.to_sym] }.first(100)
if min_average_time
query_stats.reject! { |q| q[:average_time] < min_average_time }
end
if min_calls
query_stats.reject! { |q| q[:calls] < min_calls }
end
query_stats
end
def query_stats_available?
select_one("SELECT COUNT(*) AS count FROM pg_available_extensions WHERE name = 'pg_stat_statements'") > 0
end
# only cache if true
def query_stats_enabled?
@query_stats_enabled ||= query_stats_readable?
end
def query_stats_extension_enabled?
select_one("SELECT COUNT(*) AS count FROM pg_extension WHERE extname = 'pg_stat_statements'") > 0
end
def query_stats_readable?
select_all("SELECT * FROM pg_stat_statements LIMIT 1")
true
rescue ActiveRecord::StatementInvalid
false
end
def enable_query_stats
execute("CREATE EXTENSION IF NOT EXISTS pg_stat_statements")
true
end
def disable_query_stats
execute("DROP EXTENSION IF EXISTS pg_stat_statements")
true
end
def reset_query_stats(**options)
raise PgHero::Error, "Use reset_instance_query_stats to pass database" if options.delete(:database)
reset_instance_query_stats(**options, database: database_name)
end
# resets query stats for the entire instance
# it's possible to reset stats for a specific
# database, user or query hash in Postgres 12+
def reset_instance_query_stats(database: nil, user: nil, query_hash: nil, raise_errors: false)
if database || user || query_hash
raise PgHero::Error, "Requires PostgreSQL 12+" if server_version_num < 120000
if database
database_id = execute("SELECT oid FROM pg_database WHERE datname = #{quote(database)}").first.try(:[], "oid")
raise PgHero::Error, "Database not found: #{database}" unless database_id
else
database_id = 0
end
if user
user_id = execute("SELECT usesysid FROM pg_user WHERE usename = #{quote(user)}").first.try(:[], "usesysid")
raise PgHero::Error, "User not found: #{user}" unless user_id
else
user_id = 0
end
if query_hash
query_id = query_hash.to_i
# may not be needed
# but not intuitive that all query hashes are reset with 0
raise PgHero::Error, "Invalid query hash: #{query_hash}" if query_id == 0
else
query_id = 0
end
execute("SELECT pg_stat_statements_reset(#{quote(user_id.to_i)}, #{quote(database_id.to_i)}, #{quote(query_id.to_i)})")
else
execute("SELECT pg_stat_statements_reset()")
end
true
rescue ActiveRecord::StatementInvalid => e
raise e if raise_errors
false
end
# https://stackoverflow.com/questions/20582500/how-to-check-if-a-table-exists-in-a-given-schema
def historical_query_stats_enabled?
# TODO use schema from config
# make sure primary database is PostgreSQL first
query_stats_table_exists? && capture_query_stats? && !missing_query_stats_columns.any?
end
def query_stats_table_exists?
table_exists?("pghero_query_stats")
end
def missing_query_stats_columns
%w(query_hash user) - PgHero::QueryStats.column_names
end
def supports_query_hash?
server_version_num >= 90400
end
# resetting query stats will reset across the entire Postgres instance in Postgres < 12
# this is problematic if multiple PgHero databases use the same Postgres instance
#
# to get around this, we capture queries for every Postgres database before we
# reset query stats for the Postgres instance with the `capture_query_stats` option
def capture_query_stats(raise_errors: false)
return if config["capture_query_stats"] && config["capture_query_stats"] != true
# get all databases that use same query stats and build mapping
mapping = {id => database_name}
PgHero.databases.select { |_, d| d.config["capture_query_stats"] == id }.each do |_, d|
mapping[d.id] = d.database_name
end
now = Time.now
query_stats = {}
mapping.each do |database_id, database_name|
query_stats[database_id] = query_stats(limit: 1000000, database: database_name)
end
query_stats = query_stats.select { |_, v| v.any? }
# nothing to do
return if query_stats.empty?
# reset individual databases for Postgres 12+ instance
if server_version_num >= 120000
query_stats.each do |db_id, db_query_stats|
if reset_instance_query_stats(database: mapping[db_id], raise_errors: raise_errors)
insert_query_stats(db_id, db_query_stats, now)
end
end
else
if reset_instance_query_stats(raise_errors: raise_errors)
query_stats.each do |db_id, db_query_stats|
insert_query_stats(db_id, db_query_stats, now)
end
end
end
end
def clean_query_stats(before: nil)
before ||= 14.days.ago
PgHero::QueryStats.where(database: id).where("captured_at < ?", before).delete_all
end
def slow_queries(query_stats: nil, **options)
query_stats ||= self.query_stats(**options)
query_stats.select { |q| q[:calls].to_i >= slow_query_calls.to_i && q[:average_time].to_f >= slow_query_ms.to_f }
end
def query_hash_stats(query_hash, user: nil, current: false)
if historical_query_stats_enabled? && supports_query_hash?
start_at = 24.hours.ago
stats = select_all_stats <<~SQL
SELECT
captured_at,
total_time / 1000 / 60 AS total_minutes,
(total_time / calls) AS average_time,
calls,
(SELECT regexp_matches(query, '.*/\\*(.+?)\\*/'))[1] AS origin
FROM
pghero_query_stats
WHERE
database = #{quote(id)}
AND captured_at >= #{quote(start_at)}
AND query_hash = #{quote(query_hash)}
#{user ? "AND \"user\" = #{quote(user)}" : ""}
ORDER BY
1 ASC
SQL
if current
captured_at = Time.current
current_stats = current_query_stats(query_hash: query_hash, user: user, origin: true)
current_stats.each do |r|
r[:captured_at] = captured_at
end
stats += current_stats
end
stats
else
raise NotEnabled, "Query hash stats not enabled"
end
end
private
# http://www.craigkerstiens.com/2013/01/10/more-on-postgres-performance/
def current_query_stats(limit: nil, sort: nil, database: nil, query_hash: nil, user: nil, origin: false)
if query_stats_enabled?
limit ||= 100
sort ||= "total_minutes"
total_time = server_version_num >= 130000 ? "(total_plan_time + total_exec_time)" : "total_time"
query = <<~SQL
WITH query_stats AS (
SELECT
LEFT(query, 10000) AS query,
#{supports_query_hash? ? "queryid" : "md5(query)"} AS query_hash,
rolname AS user,
(#{total_time} / 1000 / 60) AS total_minutes,
(#{total_time} / calls) AS average_time,
calls
FROM
pg_stat_statements
INNER JOIN
pg_database ON pg_database.oid = pg_stat_statements.dbid
INNER JOIN
pg_roles ON pg_roles.oid = pg_stat_statements.userid
WHERE
calls > 0 AND
pg_database.datname = #{database ? quote(database) : "current_database()"}
#{query_hash ? "AND queryid = #{quote(query_hash)}" : nil}
#{user ? "AND rolname = #{quote(user)}" : nil}
)
SELECT
query,
query AS explainable_query,
#{origin ? "(SELECT regexp_matches(query, '.*/\\*(.+?)\\*/'))[1] AS origin," : nil}
query_hash,
query_stats.user,
total_minutes,
average_time,
calls,
total_minutes * 100.0 / (SELECT SUM(total_minutes) FROM query_stats) AS total_percent,
(SELECT SUM(total_minutes) FROM query_stats) AS all_queries_total_minutes
FROM
query_stats
ORDER BY
#{quote_column_name(sort)} DESC
LIMIT #{limit.to_i}
SQL
# we may be able to skip query_columns
# in more recent versions of Postgres
# as pg_stat_statements should be already normalized
select_all(query, query_columns: [:query, :explainable_query])
else
raise NotEnabled, "Query stats not enabled"
end
end
def historical_query_stats(sort: nil, start_at: nil, end_at: nil, query_hash: nil)
if historical_query_stats_enabled?
sort ||= "total_minutes"
query = <<~SQL
WITH query_stats AS (
SELECT
#{supports_query_hash? ? "query_hash" : "md5(query)"} AS query_hash,
pghero_query_stats.user AS user,
array_agg(LEFT(query, 10000) ORDER BY REPLACE(LEFT(query, 1000), '?', '!') COLLATE "C" ASC) AS query,
(SUM(total_time) / 1000 / 60) AS total_minutes,
(SUM(total_time) / SUM(calls)) AS average_time,
SUM(calls) AS calls
FROM
pghero_query_stats
WHERE
database = #{quote(id)}
#{supports_query_hash? ? "AND query_hash IS NOT NULL" : ""}
#{start_at ? "AND captured_at >= #{quote(start_at)}" : ""}
#{end_at ? "AND captured_at <= #{quote(end_at)}" : ""}
#{query_hash ? "AND query_hash = #{quote(query_hash)}" : ""}
GROUP BY
1, 2
)
SELECT
query_hash,
query_stats.user,
query[1] AS query,
query[array_length(query, 1)] AS explainable_query,
total_minutes,
average_time,
calls,
total_minutes * 100.0 / (SELECT SUM(total_minutes) FROM query_stats) AS total_percent,
(SELECT SUM(total_minutes) FROM query_stats) AS all_queries_total_minutes
FROM
query_stats
ORDER BY
#{quote_column_name(sort)} DESC
LIMIT 100
SQL
# we can skip query_columns if all stored data is normalized
# for now, assume it's not
select_all_stats(query, query_columns: [:query, :explainable_query])
else
raise NotEnabled, "Historical query stats not enabled"
end
end
def combine_query_stats(grouped_stats)
query_stats = []
grouped_stats.each do |_, stats2|
value = {
query: (stats2.find { |s| s[:query] } || {})[:query],
user: (stats2.find { |s| s[:user] } || {})[:user],
query_hash: (stats2.find { |s| s[:query_hash] } || {})[:query_hash],
total_minutes: stats2.sum { |s| s[:total_minutes] },
calls: stats2.sum { |s| s[:calls] }.to_i,
all_queries_total_minutes: stats2.sum { |s| s[:all_queries_total_minutes] }
}
value[:total_percent] = value[:total_minutes] * 100.0 / value[:all_queries_total_minutes]
value[:explainable_query] = stats2.map { |s| s[:explainable_query] }.find { |q| q && explainable?(q) }
query_stats << value
end
query_stats
end
def explainable?(query)
query =~ /select/i && (server_version_num >= 160000 || (!query.include?("?)") && !query.include?("= ?") && !query.include?("$1") && query !~ /limit \?/i))
end
# removes comments
# combines ?, ?, ? => ?
def normalize_query(query)
squish(query.to_s.gsub(/\?(, ?\?)+/, "?").gsub(/\/\*.+?\*\//, ""))
end
def insert_query_stats(db_id, db_query_stats, now)
values =
db_query_stats.map do |qs|
{
database: db_id,
query: qs[:query],
total_time: qs[:total_minutes] * 60 * 1000,
calls: qs[:calls],
captured_at: now,
query_hash: supports_query_hash? ? qs[:query_hash] : nil,
user: qs[:user]
}
end
PgHero::QueryStats.insert_all!(values)
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/lib/pghero/methods/kill.rb | lib/pghero/methods/kill.rb | module PgHero
module Methods
module Kill
def kill(pid)
select_one("SELECT pg_terminate_backend(#{pid.to_i})")
end
def kill_long_running_queries(min_duration: nil)
running_queries(min_duration: min_duration || long_running_query_sec).each { |query| kill(query[:pid]) }
true
end
def kill_all
select_all <<~SQL
SELECT
pg_terminate_backend(pid)
FROM
pg_stat_activity
WHERE
pid <> pg_backend_pid()
AND query <> '<insufficient privilege>'
AND datname = current_database()
SQL
true
end
end
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
ankane/pghero | https://github.com/ankane/pghero/blob/c11401560bdae3477a531f799168355d45e789aa/config/routes.rb | config/routes.rb | PgHero::Engine.routes.draw do
scope "(:database)", constraints: proc { |req| (PgHero.config["databases"].keys + [nil]).include?(req.params[:database]) } do
get "space", to: "home#space"
get "space/:relation", to: "home#relation_space", as: :relation_space
get "index_bloat", to: "home#index_bloat"
get "live_queries", to: "home#live_queries"
get "queries", to: "home#queries"
get "queries/:query_hash", to: "home#show_query", as: :show_query
get "system", to: "home#system"
get "cpu_usage", to: "home#cpu_usage"
get "connection_stats", to: "home#connection_stats"
get "replication_lag_stats", to: "home#replication_lag_stats"
get "load_stats", to: "home#load_stats"
get "free_space_stats", to: "home#free_space_stats"
get "explain", to: "home#explain"
get "tune", to: "home#tune"
get "connections", to: "home#connections"
get "maintenance", to: "home#maintenance"
post "kill", to: "home#kill"
post "kill_long_running_queries", to: "home#kill_long_running_queries"
post "kill_all", to: "home#kill_all"
post "enable_query_stats", to: "home#enable_query_stats"
post "explain", to: "home#explain"
post "reset_query_stats", to: "home#reset_query_stats"
# legacy routes
get "system_stats" => redirect("system")
get "query_stats" => redirect("queries")
root to: "home#index"
end
end
| ruby | MIT | c11401560bdae3477a531f799168355d45e789aa | 2026-01-04T15:38:52.602437Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_gb_locale.rb | test/test_en_gb_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnGbLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-GB'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_gb_address_methods
assert_kind_of String, Faker::Address.county
assert_kind_of String, Faker::Address.uk_country
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.postcode
end
def test_en_gb_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_gb_country_code
assert_equal('+44', Faker::PhoneNumber.country_code)
end
def test_en_gb_phone_starts_with_zero
phone = Faker::PhoneNumber.phone_number.gsub(/\D/, '')
assert_equal '0', phone[0]
end
def test_en_gb_cell_phone_starts_with_zero
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '0', mobile[0]
end
def test_en_gb_cell_phone_is_valid
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_match(/07[13456789]\d{8}/, mobile)
# Pager numbers begin with 070 and 076xx. 07624 is used for mobiles on the Isle of Man
refute_equal(/076(?!24)\d{8}|070\d{8}/, mobile)
end
def test_en_gb_postcode_has_outcode_and_incode
postcode = Faker::Address.postcode
assert_equal 2, postcode.split.length
end
def test_en_gb_postcode_incode_is_valid
# The letters C I K M O V are not used in the second part of the Postcode.
incode = Faker::Address.postcode.split[1]
assert_match(/\d[ABDEFGHJLNPQRSTUWXYZ]{2}/, incode)
end
def test_en_gb_postcode_outcode_is_valid
outcode = Faker::Address.postcode.split[0]
assert_includes(2..4, outcode.length)
assert_match(/\w{1,2}\d{1,2}\w?/, outcode)
assert_match(/^[A-PR-UWYZ][A-HK-Y0-9]/, outcode)
assert_match(/\w{1,2}\d{1,2}|\w\d[ABCDEFGHJKPSTUW]|\w\w\d[ABEHMNPRVWXY]/, outcode)
end
def test_en_gb_id_number_valid
id_code = Faker::IdNumber.valid
assert_equal(9, id_code.length)
assert_match(/^[A-CEGHJ-PR-TW-Z][A-CEGHJ-NPR-TW-Z][0-9]{6}[A-DFM]$/, id_code)
end
def test_en_gb_id_number_invalid
id_code = Faker::IdNumber.invalid
assert_equal(9, id_code.length)
assert_not_match(/^[A-CEGHJ-PR-TW-Z][A-CEGHJ-NPR-TW-Z][0-9]{6}[A-DFM]$/, id_code)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_fr_ch_locale.rb | test/test_fr_ch_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestFrChLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'fr-CH'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_fr_ch_address_methods
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_match(/^\d+$/, Faker::Address.building_number)
assert_equal('Suisse', Faker::Address.default_country)
end
def test_fr_ch_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.quote
end
def test_fr_ch_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_fr_ch_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_fr_ch_lorem_methods
assert_kind_of String, Faker::Lorem.word
assert Faker::Lorem.words(number: 1000)
assert Faker::Lorem.words(number: 10_000, supplemental: true)
end
def test_fr_ch_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_fr_ch_phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
assert_kind_of String, Faker::Games::Pokemon.name
assert_kind_of String, Faker::Games::Pokemon.location
assert_kind_of String, Faker::Games::Pokemon.move
end
def test_fr_ch_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
assert_kind_of String, Faker::Games::Pokemon.location
assert_kind_of String, Faker::Games::Pokemon.move
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_determinism.rb | test/test_determinism.rb | # frozen_string_literal: true
require_relative 'test_helper'
# rubocop:disable Security/Eval,Style/EvalWithLocation
class TestDeterminism < Test::Unit::TestCase
def setup
@all_methods = all_methods.freeze
@first_run = []
end
def test_determinism
Faker::Config.random = Random.new(42)
@all_methods.each_index do |index|
store_result @all_methods[index]
end
@first_run.freeze
Faker::Config.random = Random.new(42)
@all_methods.each_index do |index|
assert deterministic_random? @first_run[index], @all_methods[index]
end
end
def test_thread_safety
expected_values = 2.times.map do |index|
Faker::Config.random = Random.new(index)
Faker::Number.digit
end
threads = expected_values.each_with_index.map do |expected_value, index|
Thread.new do
100_000.times.each do
Faker::Config.random = Random.new(index)
output = Faker::Number.digit
assert_equal output, expected_value
end
end
end
threads.each(&:join)
end
private
def deterministic_random?(first, method_name)
second = eval(method_name)
(first == second) || raise(
"#{method_name} has an entropy leak; use \"Faker::Config.random.rand\" or \"Array#sample(random: Faker::Config.random)\". Method to lookup for: sample, shuffle, rand"
)
end
def store_result(method_name)
@first_run << eval(method_name)
rescue StandardError => e
raise %(#{method_name} raised "#{e}")
end
def all_methods
subclasses.map do |subclass|
subclass_methods(subclass).flatten
end.flatten.sort
end
def subclasses
Faker.constants.delete_if do |subclass|
skipped_classes.include?(subclass)
end.sort
end
def subclass_methods(subclass)
eval("Faker::#{subclass}.public_methods(false) - Faker::Base.public_methods(false)").sort.map do |method|
"Faker::#{subclass}.#{method}"
end.sort
end
def skipped_classes
%i[
Bank
Base
Base58
Books
Cat
Char
ChileRut
CLI
Config
Creature
Date
Deprecator
Dog
DragonBall
Dota
ElderScrolls
Fallout
Games
GamesHalfLife
HeroesOfTheStorm
Internet
JapaneseMedia
LeagueOfLegends
Locations
Movies
Myst
Overwatch
OnePiece
Pokemon
Religion
Sports
SwordArtOnline
TvShows
Time
VERSION
Witcher
WorldOfWarcraft
Zelda
]
end
end
# rubocop:enable Security/Eval,Style/EvalWithLocation
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_nep_locale.rb | test/test_en_nep_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnNepLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-NEP'
end
def teardown
Faker::Config.locale = nil
end
def test_en_nep_address_methods
assert_kind_of String, Faker::Address.default_time_zone
assert_kind_of String, Faker::Address.default_country_code
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.default_country
end
def test_en_nep_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_nep_name_methods
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.middle_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_equal 'Nepal', Faker::Address.default_country
end
def test_en_nep_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_es_mx_locale.rb | test/test_es_mx_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEsMxLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'es-MX'
end
def teardown
Faker::Config.locale = nil
end
def test_es_mx_address
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_empty Faker::Address.city_prefix
assert_empty Faker::Address.city_suffix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.city(options: { with_state: true })
assert_equal(2, Faker::Address.city(options: { with_state: true }).split(', ').count)
assert_kind_of String, Faker::Address.secondary_address
end
def test_es_mx_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.prefix
assert_kind_of String, Faker::Company.name
end
def test_es_mx_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_es_mx_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_es_mx_phone_number
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_es_mx_subscription_methods
assert_kind_of String, Faker::Subscription.plan
assert_kind_of String, Faker::Subscription.status
assert_kind_of String, Faker::Subscription.payment_method
assert_kind_of String, Faker::Subscription.subscription_term
assert_kind_of String, Faker::Subscription.payment_term
end
def test_es_mx_university_methods
assert_kind_of String, Faker::University.suffix
assert_kind_of String, Faker::University.prefix
end
def test_es_mx_finance_vat_number
vat = Faker::Finance.vat_number(country: 'MX')
assert_kind_of String, vat
assert_match(/([A-ZÑ]){3,4}(\d){6}([A-Z0-9]){3}/, vat)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_th_locale.rb | test/test_en_th_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnThLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-TH'
end
def teardown
Faker::Config.locale = nil
end
def test_en_th_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ng_locale.rb | test/test_en_ng_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnNgLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-NG'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_ng_address_methods
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.region
assert_kind_of String, Faker::Address.lga
assert_equal 'Nigeria', Faker::Address.default_country
end
def test_en_ng_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_en_ng_phonenumber_is_11_digits
phone_number = Faker::PhoneNumber.phone_number
assert_equal 11, phone_number.length
end
def test_en_ng_phonenumber_starts_with_0
phone_number = Faker::PhoneNumber.phone_number
assert_equal '0', phone_number[0]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_id_locale.rb | test/test_id_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestIdLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'id'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_id_address_methods
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.province
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.street_title
assert_kind_of String, Faker::Address.street_name
end
def test_id_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_id_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ru_locale.rb | test/test_ru_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestRuLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'ru'
end
def teardown
Faker::Config.locale = nil
end
def test_ru_address_methods
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.street_title
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.full_address
assert_kind_of String, Faker::Address.street_address
assert_equal 'Россия', Faker::Address.default_country
end
def test_ru_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
end
def test_ru_company_methods
assert_kind_of String, Faker::Company.prefix
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_ru_char_methods
assert_kind_of String, Faker::Char.romanize_cyrillic('')
end
def test_ru_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_ru_name_methods
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.male_middle_name
assert_kind_of String, Faker::Name.male_last_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.female_middle_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_de_at_locale.rb | test/test_de_at_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestDeAtLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'de-AT'
end
def teardown
Faker::Config.locale = nil
end
def test_de_at_address_methods
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_address
assert_equal('Österreich', Faker::Address.default_country)
end
def test_de_at_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.legal_form
end
def test_de_at_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_de_at_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.nobility_title_prefix
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_de_at_phone_number_methods
assert_match(/(43)|(06)|(436)[\d\s]+$/, Faker::PhoneNumber.cell_phone_with_country_code)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_bg_locale.rb | test/test_bg_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestBgLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'bg'
end
def teardown
Faker::Config.locale = nil
end
def test_bg_methods
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.street_title
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_equal 'България', Faker::Address.default_country
end
def test_bg_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_bg_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.male_middle_name
assert_kind_of String, Faker::Name.male_last_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.female_middle_name
assert_kind_of String, Faker::Name.female_middle_name
assert_kind_of String, Faker::Name.name
end
def test_bg_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_bg_cell_number_starts_wiht_08
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '08', mobile[0] + mobile[1]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_da_dk_locale.rb | test/test_da_dk_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestDaDkLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'da-DK'
end
def teardown
Faker::Config.locale = nil
end
def test_da_dk_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.street_address
assert_match(/\d{4}$/, Faker::Address.postcode)
assert_match(/\d{1,3}$/, Faker::Address.building_number)
assert_equal 'Danmark', Faker::Address.default_country
end
def test_da_dk_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_da_dk_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Commerce.name
end
def test_da_dk_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_da_dk_name_methods
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.prefix
end
def test_da_dk_phone_number_methods
assert_match(/(20)|(30)|(40)[\d\s]+$/, Faker::PhoneNumber.cell_phone)
assert_match(/(\d\d[\s-]?){4}$/, Faker::PhoneNumber.phone_number)
end
def test_da_dk_counrty_code
assert_equal '+45', Faker::PhoneNumber.country_code
assert_match(/(\+45)\s(\d\d[\s-]?){4}$/, Faker::PhoneNumber.phone_number_with_country_code)
assert_match(/(\+45)\s(\d\d[\s-]?){4}$/, Faker::PhoneNumber.cell_phone_with_country_code)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_hy_locale.rb | test/test_hy_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestHyLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'hy'
end
def teardown
Faker::Config.locale = nil
end
def test_hy_address_methods
assert_kind_of String, Faker::Address.country
assert_equal 'Ամերիկայի Միացյալ Նահանգներ', Faker::Address.country_by_code(code: 'US')
assert_equal 'Հայաստան', Faker::Address.default_country
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.community
assert_kind_of String, Faker::Address.city
assert_equal 'ք.', Faker::Address.city_prefix
assert_kind_of String, Faker::Address.village
assert_equal 'գ.', Faker::Address.village_prefix
assert_equal '+374', Faker::PhoneNumber.country_code
assert Faker::Address.zip_code.start_with?('0', '1', '2', '3', '4')
assert Faker::Address.zip(state_abbreviation: 'ԱԳ').start_with?('02', '03', '04', '05')
assert Faker::Address.zip(state_abbreviation: 'ԱՐ').start_with?('06', '07', '08')
assert Faker::Address.zip(state_abbreviation: 'ԱՄ').start_with?('09', '10', '11')
assert Faker::Address.zip(state_abbreviation: 'ԳՂ').start_with?('12', '13', '14', '15', '16')
assert Faker::Address.zip(state_abbreviation: 'ԼՌ').start_with?('17', '18', '19', '20', '21')
assert Faker::Address.zip(state_abbreviation: 'ԿՏ').start_with?('22', '23', '24', '25')
assert Faker::Address.zip(state_abbreviation: 'ՇԿ').start_with?('26', '27', '28', '29', '30', '31')
assert Faker::Address.zip(state_abbreviation: 'ՍՅ').start_with?('32', '33', '34', '35')
assert Faker::Address.zip(state_abbreviation: 'ՎՁ').start_with?('36', '37', '38')
assert Faker::Address.zip(state_abbreviation: 'ՏՎ').start_with?('39', '40', '41', '42')
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_includes %w[փողոց պողոտա], Faker::Address.street_suffix
assert_includes 1..3, Faker::Address.building_number.size
assert Faker::Address.secondary_address.start_with?('բն. ')
assert_kind_of String, Faker::Address.full_address
end
def test_hy_artist_methods
assert_kind_of String, Faker::Artist.name
end
def test_hy_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.genre
end
def test_hy_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_hy_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.material
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Commerce.promotion_code
end
def test_hy_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.industry
assert_kind_of String, Faker::Company.catch_phrase
assert_kind_of String, Faker::Company.profession
assert_kind_of String, Faker::Company.type
end
def test_hy_compass_methods
assert_kind_of String, Faker::Compass.abbreviation
assert_kind_of String, Faker::Compass.cardinal
assert_kind_of String, Faker::Compass.cardinal_abbreviation
assert_kind_of String, Faker::Compass.direction
assert_kind_of String, Faker::Compass.half_wind
assert_kind_of String, Faker::Compass.half_wind_abbreviation
assert_kind_of String, Faker::Compass.ordinal
assert_kind_of String, Faker::Compass.ordinal_abbreviation
end
def test_hy_currency_methods
assert_kind_of String, Faker::Currency.name
end
def test_hy_food_methods
assert_kind_of String, Faker::Food.dish
assert_kind_of String, Faker::Food.descriptions
assert_kind_of String, Faker::Food.ingredients
assert_kind_of String, Faker::Food.fruits
assert_kind_of String, Faker::Food.vegetables
assert_kind_of String, Faker::Food.spices
assert_kind_of String, Faker::Food.measurements
assert_kind_of String, Faker::Food.metric_measurements
end
def test_hy_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_name
assert_kind_of String, Faker::Internet.domain_suffix
assert_kind_of String, Faker::Internet.domain_word
end
def test_hy_job_methods
assert_kind_of String, Faker::Job.field
assert_kind_of String, Faker::Job.seniority
assert_kind_of String, Faker::Job.position
assert_kind_of String, Faker::Job.key_skills
assert_kind_of String, Faker::Job.employment_type
assert_kind_of String, Faker::Job.education_level
assert_kind_of String, Faker::Job.title
end
def test_hy_military_methods
assert_kind_of String, Faker::Military.army_rank
end
def test_hy_name_methods
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_hy_nation_methods
assert_kind_of String, Faker::Nation.nationality
assert_kind_of String, Faker::Nation.language
assert_kind_of String, Faker::Nation.capital_city
end
def test_hy_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.cell_phone
assert_kind_of String, Faker::PhoneNumber.phone_number
end
def test_hy_science_methods
assert_kind_of String, Faker::Science.element
assert_kind_of String, Faker::Science.scientist
end
def test_hy_space_methods
assert_kind_of String, Faker::Space.planet
assert_kind_of String, Faker::Space.moon
assert_kind_of String, Faker::Space.galaxy
assert_kind_of String, Faker::Space.nebula
assert_kind_of String, Faker::Space.constellation
assert_kind_of String, Faker::Space.star
assert_kind_of String, Faker::Space.distance_measurement
assert_kind_of String, Faker::Space.meteorite
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_es_locale.rb | test/test_es_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
LoadedEsYaml = %w[en es].each_with_object({}) do |locale, h|
h[locale] = YAML.load_file(File.expand_path(File.dirname(__FILE__) + "/../lib/locales/#{locale}.yml"))[locale]['faker']
end
class TestEsLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'es'
end
def teardown
Faker::Config.locale = nil
end
def test_locale_separate_from_i18n
I18n.locale = :en
assert_match(//, Faker::Address.street_name)
end
def test_configured_locale_translation
assert_equal Faker::Base.translate('faker.address.city_prefix').first, LoadedEsYaml['es']['address']['city_prefix'].first
end
def test_locale_override_when_calling_translate
assert_equal Faker::Base.translate('faker.separator', locale: :en), LoadedEsYaml['en']['separator']
end
def test_translation_fallback
assert_nil LoadedEsYaml['es']['company']['bs']
assert_not_nil LoadedEsYaml['es']['address']['city_prefix']
assert_equal Faker::Base.translate('faker.address.city_prefix'), LoadedEsYaml['es']['address']['city_prefix']
end
def test_es_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert Faker::Address.default_country, 'España'
end
def test_es_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_es_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.suffix
end
def test_es_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_es_food_methods
assert_kind_of String, Faker::Food.ingredient
assert_kind_of String, Faker::Food.spice
assert_kind_of String, Faker::Food.measurement
end
def test_es_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_es_name_methods
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.middle_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.name
assert_match(/[A-Z]{3}/, Faker::Name.initials)
assert_match(/[A-Z]{2}/, Faker::Name.initials(number: 2))
end
def test_es_vehicle_methods
assert_kind_of String, Faker::Vehicle.license_plate
assert_match(/\d{4}[A-Z]{3}/, Faker::Vehicle.license_plate)
assert_match(/GR\d{4}[A-Z]{1,2}/, Faker::Vehicle.license_plate(state_abbreviation: 'GR'))
end
def test_es_subscription_methods
assert_kind_of String, Faker::Subscription.plan
assert_kind_of String, Faker::Subscription.status
assert_kind_of String, Faker::Subscription.payment_method
assert_kind_of String, Faker::Subscription.subscription_term
assert_kind_of String, Faker::Subscription.payment_term
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_uk_locale.rb | test/test_uk_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestUkLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'uk'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_uk_zipcode_length
assert_match(/^\d{5}$/, Faker::Address.zip_code)
assert_send([Faker::Address, :street_prefix])
end
def test_uk_address_absent
assert_nil(Faker::Address.city_prefix)
assert_nil(Faker::Address.city_suffix)
assert_nil(Faker::Address.state_abbr)
end
def test_uk_romanize_cyrillic
assert_kind_of String, Faker::Char.romanize_cyrillic('')
end
def test_uk_company_prefix_returns_true_value
assert_send([Faker::Company, :prefix])
end
def test_uk_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Commerce.department
end
def test_uk_internet_methods
assert_match(/.+@[^.].+\.\w+/, Faker::Internet.email)
assert_match(/^[\w-]+$/, Faker::Internet.domain_word)
end
def test_uk_name_methods
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.male_middle_name
assert_kind_of String, Faker::Name.male_last_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.female_middle_name
assert_kind_of String, Faker::Name.female_last_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ar_locale.rb | test/test_ar_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestArLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = :ar
end
def teardown
Faker::Config.locale = nil
end
def test_ar_address_methods
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.full_address
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.full_address
assert_kind_of String, Faker::Address.default_country
assert_equal('المملكة العربية السعودية', Faker::Address.default_country)
end
def test_ar_app_methods
assert_kind_of String, Faker::App.name
assert_kind_of String, Faker::App.version
assert_kind_of String, Faker::App.author
end
def test_ar_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.genre
end
def test_ar_color_name
assert_kind_of String, Faker::Color.color_name
end
def test_ar_commerce_methods
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Commerce.promotion_code
end
def test_ar_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.industry
assert_kind_of String, Faker::Company.profession
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
end
def test_ar_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.prefix
end
def test_ar_team_methods
assert_kind_of String, Faker::Team.creature
assert_kind_of String, Faker::Team.name
assert_kind_of String, Faker::Team.sport
end
def test_ar_university_methods
assert_kind_of String, Faker::University.name
assert_kind_of String, Faker::University.prefix
assert_kind_of String, Faker::University.suffix
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_nz_locale.rb | test/test_en_nz_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnNzLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-NZ'
end
def teardown
Faker::Config.locale = nil
end
def test_en_nz_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.region
assert_kind_of String, Faker::Address.region_abbr
assert_kind_of String, Faker::Address.postcode
assert_equal 'New Zealand', Faker::Address.default_country
end
def test_en_nz_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_nz_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_nz_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_en_nz_phone_number_methods
cellphone = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '0', cellphone[0]
assert_equal '2', cellphone[1]
end
def test_en_nz_team_methods
assert_kind_of String, Faker::Team.sport
assert_kind_of String, Faker::Team.name
end
def test_en_nz_university_methods
assert_kind_of String, Faker::University.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_pak_locale.rb | test/test_en_pak_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnPakLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-PAK'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_pak_methods
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.default_time_zone
assert_kind_of String, Faker::Address.postcode
assert_match(/\A(Pakistan|Islamic Republic of Pakistan)\z/, Faker::Address.default_country)
end
def test_en_pak_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_pak_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_pak_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_en_pak_cell_phone_is_valid
mobile = Faker::PhoneNumber.cell_phone
assert_match(/03\d{2}\d{7}/, mobile)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_locale.rb | test/test_en_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en'
end
def teardown
Faker::Config.locale = nil
end
def test_us_states_only_include_states
assert_equal(['Alabama', 'Alaska', 'Arizona', 'Arkansas', 'California', 'Colorado', 'Connecticut', 'Delaware', 'Florida', 'Georgia', 'Hawaii', 'Idaho', 'Illinois', 'Indiana', 'Iowa', 'Kansas', 'Kentucky', 'Louisiana', 'Maine', 'Maryland', 'Massachusetts', 'Michigan', 'Minnesota', 'Mississippi', 'Missouri', 'Montana', 'Nebraska', 'Nevada', 'New Hampshire', 'New Jersey', 'New Mexico', 'New York', 'North Carolina', 'North Dakota', 'Ohio', 'Oklahoma', 'Oregon', 'Pennsylvania', 'Rhode Island', 'South Carolina', 'South Dakota', 'Tennessee', 'Texas', 'Utah', 'Vermont', 'Virginia', 'Washington', 'West Virginia', 'Wisconsin', 'Wyoming'], I18n.translate('faker.address.state'))
assert_equal(%w[AL AK AZ AR CA CO CT DE FL GA HI ID IL IN IA KS KY LA ME MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA RI SC SD TN TX UT VT VA WA WV WI WY], I18n.translate('faker.address.state_abbr'))
end
def test_us_zip_codes
expected = /\d{5}(-\d{4})?/
assert_match(expected, Faker::Address.zip_code)
end
def test_valid_id_number
id_num = Faker::IdNumber.valid
assert(Faker::IdNumber::INVALID_SSN.none? { |regex| id_num =~ regex })
end
def test_invalid_id_number
id_num = Faker::IdNumber.invalid
assert(Faker::IdNumber::INVALID_SSN.any? { |regex| id_num =~ regex })
end
def test_values_trimmed
en_file = YAML.load_file('lib/locales/en.yml')
check_hash(en_file)
end
def check_hash(hash)
hash.each { |key, value| check_value(value) unless key == 'separator' }
end
def check_value(value)
if value.is_a?(Hash)
check_hash(value)
elsif value.is_a?(Array)
check_array(value)
else
assert_nil(value.strip!) unless value.nil?
end
end
def check_array(array)
array.each { |value| check_value(value) }
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_nl_locale.rb | test/test_nl_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestNlLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'nl'
end
def teardown
Faker::Config.locale = nil
end
def test_nl_address_methods
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_match(/\A[1-9][0-9]{3} [A-Z]{2}(?<!SA|SS|SD)\z/, Faker::Address.postcode)
assert_equal('Nederland', Faker::Address.default_country)
end
def test_nl_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
end
def test_nl_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_nl_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_nl_lorem_methods
assert_kind_of String, Faker::Lorem.word
end
def test_nl_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.tussenvoegsel
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
end
def test_nl_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_nl_cell_phone_countrycode
mobile = Faker::PhoneNumber.cell_phone_with_country_code.gsub(/\D/, '')
assert_match(/^(0|31)/, mobile)
end
def test_nl_university_methods
assert_kind_of String, Faker::University.prefix
assert_kind_of String, Faker::University.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_mi_nz_locale.rb | test/test_mi_nz_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestMaNzLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'mi-NZ'
end
def teardown
Faker::Config.locale = nil
end
def test_mi_nz_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.region
assert_kind_of String, Faker::Address.region_abbr
assert_kind_of String, Faker::Address.postcode
assert_equal 'Aotearoa', Faker::Address.default_country
end
def test_mi_nz_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_nb_no_locale.rb | test/test_nb_no_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestNbNoLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'nb-NO'
end
def teardown
Faker::Config.locale = nil
end
def test_nb_no_address_methods
assert_kind_of String, Faker::Address.city_root
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.common_street_suffix
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_equal('Norge', Faker::Address.default_country)
end
def test_nb_no_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_nb_no_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_nb_no_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
end
def test_nb_no_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.cell_phone
assert_kind_of String, Faker::PhoneNumber.phone_number
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ind_locale.rb | test/test_en_ind_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnIndLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-IND'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_ind_address_methods
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.default_country
assert_match(/\d{6}$/, Faker::Address.postcode)
assert_match(/(\w+\.? ?){2,3}/, Faker::Address.city)
end
def test_en_ind_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_ind_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_ind_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_faker.rb | test/test_faker.rb | # frozen_string_literal: true
require_relative 'test_helper'
module Faker
class TestFake
def self.a_class_method
'called a_class_method'
end
end
end
class TestFaker < Test::Unit::TestCase
def setup; end
def test_numerify
deterministically_verify -> { Faker::Base.numerify('###') }, depth: 5 do |result|
assert_match(/[1-9]\d{2}/, result)
end
end
def test_letterify
assert_match(/[A-Z]{3}/, Faker::Base.letterify('???'))
end
def test_regexify
{
'uk post code' => /^([A-PR-UWYZ0-9][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {1,2}[0-9][ABD-HJLN-UW-Z]{2}|GIR 0AA)$/,
'us phone' => /^(1-?)[2-8][0-1][0-9]-\d{3}-\d{4}$/
}.each do |label, re|
deterministically_verify -> { Faker::Base.regexify(re) } do |result|
assert_match re, result, "#{result} is not a match for #{label}"
end
end
end
def test_deterministic_numerify
Faker::Config.random = Random.new(42)
v = Faker::Base.numerify('###')
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Base.numerify('###')
end
def test_deterministic_regexify
re = /^(1-?)[2-8][0-1][0-9]-\d{3}-\d{4}$/
Faker::Config.random = Random.new(42)
v = Faker::Base.regexify(re)
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Base.regexify(re)
end
def test_deterministic_letterify
Faker::Config.random = Random.new(42)
v = Faker::Base.letterify('???')
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Base.letterify('???')
end
def test_deterministic_fetch
Faker::Config.random = Random.new(42)
v = Faker::Base.fetch('name.first_name')
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Base.fetch('name.first_name')
end
def test_deterministic_rand_in_range
Faker::Config.random = Random.new(42)
v = Faker::Base.rand_in_range(0, 1000)
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Base.rand_in_range(0, 1000)
end
def test_parse
data = {
faker: {
simple: { lookup: 'a value' },
class: {
call_method: "\#{TestFake.a_class_method}",
use_translation: "\#{TestFake.use_i18n}"
},
test_fake: { use_i18n: 'used i18n for translation' }
}
}
I18n.backend.store_translations(Faker::Config.locale, data)
assert_equal('a value', Faker::Base.parse('simple.lookup'))
assert_equal('called a_class_method', Faker::Base.parse('class.call_method'))
assert_equal('used i18n for translation', Faker::Base.parse('class.use_translation'))
end
def test_rand_for_nil
assert_nothing_raised ArgumentError do
Faker::Base.rand(nil)
end
assert_nothing_raised ArgumentError do
Faker::Base.rand
end
end
def test_rand_for_zero
assert_nothing_raised ArgumentError do
Faker::Base.rand(0)
end
assert_equal 0, Faker::Base.rand(0)
end
def test_rand_for_range
assert_nothing_raised ArgumentError do
Faker::Base.rand(0..6)
end
assert_includes 0..6, Faker::Base.rand(0..6)
end
def test_unique
unique_numbers = Array.new(8) do
Faker::Base.unique.numerify('#')
end
assert_equal(unique_numbers.uniq, unique_numbers)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_au_ocker_locale.rb | test/test_en_au_ocker_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnAuOckerLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-au-ocker'
end
def teardown
Faker::Config.locale = nil
end
def test_en_au_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.region
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.default_country
assert_equal('Australia', Faker::Address.default_country)
end
def test_en_au_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_au_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_au_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.ocker_first_name
end
def test_en_au_cell_phone_method
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '0', mobile[0]
assert_equal '4', mobile[1]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_sv_locale.rb | test/test_sv_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestSVLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'sv'
end
def teardown
Faker::Config.locale = nil
end
def test_address_methods
assert_match(/^\d{5}$/, Faker::Address.postcode)
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.common_street_suffix
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.street_address
assert_equal('Sverige', Faker::Address.default_country)
end
def test_sv_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
end
def test_sv_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.suffix
end
def test_sv_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_sv_name_methods
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.male_first_name
end
def test_sv_phone_number_methods
assert_match(/^07[036]{1}[-\s]?\d{3}[-\s]?\d{4}$/, Faker::PhoneNumber.cell_phone)
assert_match(/^\d{4}[\s-]?\d{4,6}$/, Faker::PhoneNumber.phone_number)
end
def test_sv_team_methods
assert_kind_of String, Faker::Team.suffix
assert_kind_of String, Faker::Team.name
end
def test_sv_bank_methods
assert_kind_of String, Faker::Bank.name
end
def test_sv_sport_methods
assert_kind_of String, Faker::Sport.summer_olympics_sport
assert_kind_of String, Faker::Sport.winter_olympics_sport
assert_kind_of String, Faker::Sport.summer_paralympics_sport
assert_kind_of String, Faker::Sport.winter_paralympics_sport
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_fa_locale.rb | test/test_fa_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestFaLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'fa'
end
def teardown
Faker::Config.locale = nil
end
def test_fa_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_zh_tw_locale.rb | test/test_zh_tw_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestZhLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'zh-TW'
end
def teardown
Faker::Config.locale = nil
end
def test_zh_tw_address_methods
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
end
def test_zh_tw_name_methods
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_no_match(/\s/, Faker::Name.name_with_middle)
end
def test_zh_tw_university_methods
assert_kind_of String, Faker::University.prefix
assert_kind_of String, Faker::University.suffix
assert_kind_of String, Faker::University.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_fr_locale.rb | test/test_fr_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestFrLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'fr'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_fr_address_methods
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.full_address
assert_match(/^\d{5}$/, Faker::Address.postcode)
assert_match(/^\d+$/, Faker::Address.building_number)
full_address_regex = /(([-a-zA-ZéÉèÈàÀùÙâÂêÊîÎôÔûÛïÏëËüÜçÇæœ'.]*\s)\d*(\s[-a-zA-ZéÉèÈàÀùÙâÂêÊîÎôÔûÛïÏëËüÜçÇæœ']*)*,)*\d*(\s[-a-zA-ZéÉèÈàÀùÙâÂêÊîÎôÔûÛïÏëËüÜçÇæœ']*)+,\s(\d{5})\s[-a-zA-ZéÉèÈàÀùÙâÂêÊîÎôÔûÛïÏëËüÜçÇæœ']+/
assert_match(full_address_regex, Faker::Address.full_address)
assert_equal('France', Faker::Address.default_country)
end
def test_fr_adjective_methods
assert_kind_of String, Faker::Adjective.positive
assert_kind_of String, Faker::Adjective.negative
end
def test_fr_ancient_methods
assert_kind_of String, Faker::Ancient.god
assert_kind_of String, Faker::Ancient.primordial
assert_kind_of String, Faker::Ancient.titan
assert_kind_of String, Faker::Ancient.hero
end
def test_fr_appliance_methods
assert_kind_of String, Faker::Appliance.equipment
end
def test_fr_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.quote
end
def test_fr_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_fr_compass_methods
direction_pattern = /^\w+(-\w+){0,2}$/
cardinal_pattern = /^\w+$/
ordinal_pattern = /^\w+(-\w+){1}$/
half_wind_patern = /^\w+(-\w+){2}$/
letter_pattern = /^[NEOS]{1,3}$/
assert_match(direction_pattern, Faker::Compass.direction)
assert_match(cardinal_pattern, Faker::Compass.cardinal)
assert_match(ordinal_pattern, Faker::Compass.ordinal)
assert_match(half_wind_patern, Faker::Compass.half_wind)
assert_match(letter_pattern, Faker::Compass.abbreviation)
assert_match(letter_pattern, Faker::Compass.cardinal_abbreviation)
assert_match(letter_pattern, Faker::Compass.ordinal_abbreviation)
assert_match(letter_pattern, Faker::Compass.half_wind_abbreviation)
end
def test_fr_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_fr_demographic_methods
assert_includes %w[Homme Femme], Faker::Demographic.sex
end
def test_fr_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_fr_gender_methods
assert_includes %w[Masculin Féminin], Faker::Gender.binary_type
end
def test_fr_lorem_methods
assert_kind_of String, Faker::Lorem.word
assert Faker::Lorem.words(number: 1000)
assert Faker::Lorem.words(number: 10_000, supplemental: true)
end
def test_fr_measurement_methods
metric_height_pattern = /mètre/
metric_length_pattern = /mètre/
metric_volume_pattern = /litre|cube/
metric_weight_patern = /gramme|tonne/
assert_match(metric_height_pattern, Faker::Measurement.metric_height)
assert_match(metric_length_pattern, Faker::Measurement.metric_length)
assert_match(metric_volume_pattern, Faker::Measurement.metric_volume)
assert_match(metric_weight_patern, Faker::Measurement.metric_weight)
end
def test_fr_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_fr_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_fr_phone_format
phone = Faker::PhoneNumber.phone_number_with_country_code.gsub(/\D/, '')
assert_match(/^(0|33)\d{8,10}$/, phone)
end
def test_fr_cell_phone_format
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_match(/^0?(6|7)\d{8}$/, mobile)
end
def test_fr_creature_methods
assert_kind_of String, Faker::Creature::Animal.name
end
def test_fr_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
assert_kind_of String, Faker::Games::Pokemon.location
assert_kind_of String, Faker::Games::Pokemon.move
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ca_locale.rb | test/test_ca_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestCaLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'ca'
end
def teardown
Faker::Config.locale = nil
end
def test_ca_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_ca_name_methods
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.female_prefix
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.male_prefix
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ke_locale.rb | test/test_en_ke_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnKeLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-KE'
end
def teardown
Faker::Config.locale = nil
end
def test_en_ke_address_methods
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.county
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.default_country_code
end
def test_en_ke_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.company_names
end
def test_en_ke_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_ke_country_code_starts_with_254
phone_number = Faker::PhoneNumber.country_code
assert_equal '+254', phone_number[0..3]
end
def test_en_ke_cell_phone_starts_with_0
cell_number = Faker::PhoneNumber.cell_phone
assert_equal '0', cell_number[0]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_it_locale.rb | test/test_it_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestItLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'it'
end
def teardown
Faker::Config.locale = nil
end
def test_it_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.building_number
assert_equal('Italia', Faker::Address.default_country)
end
def test_it_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of Array, Faker::Company.buzzwords
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_it_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_it_name_methods
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
assert_equal('.', Faker::Name.prefix[-1, 1])
end
def test_it_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
end
def test_it_subscription_methods
assert_kind_of String, Faker::Subscription.plan
assert_kind_of String, Faker::Subscription.status
assert_kind_of String, Faker::Subscription.payment_method
assert_kind_of String, Faker::Subscription.subscription_term
assert_kind_of String, Faker::Subscription.payment_term
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_vi_locale.rb | test/test_vi_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestViLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'vi'
end
def teardown
Faker::Config.locale = nil
end
def test_vi_address_methods
assert_kind_of String, Faker::Address.city_root
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.county
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.city_root
assert_kind_of String, Faker::Address.city_root
assert_equal('Việt Nam', Faker::Address.default_country)
end
def test_vi_company_methods
assert_kind_of String, Faker::Company.prefix
assert_kind_of String, Faker::Company.name
end
def test_vi_lorem_methods
assert_kind_of String, Faker::Lorem.word
end
def test_vi_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_vi_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_vi_name_methods
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ee_locale.rb | test/test_ee_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEeLocale < Test::Unit::TestCase
def setup
@valid_phone_prefixes = %w[32 33 35 38 39 43 44 45 46 47 48 61 62 63 64 65
66 67 68 69 71 72 73 74 75 76 77 78 79 88].sort
@valid_cell_phone_prefixes = %w[5 8].sort
@previous_locale = Faker::Config.locale
Faker::Config.locale = :ee
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_ee_address_methods
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.country_code
end
def test_ee_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of Array, Faker::Company.buzzwords
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_ee_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_ee_invoice_methods
assert_kind_of String, Faker::Invoice.creditor_reference
assert_kind_of String, Faker::Invoice.reference
assert_kind_of String, Faker::Invoice.reference(ref: '4106453482608858924')
end
def test_ee_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name_with_middle
end
def test_ee_phone_number
deterministically_verify -> { Faker::PhoneNumber.phone_number[0..1] }, depth: 5 do |phone_number_prefix|
assert_include @valid_phone_prefixes, phone_number_prefix
end
end
def test_ee_cell_phone_with_country_code
phone_number = Faker::PhoneNumber.phone_number_with_country_code
assert_match(/\+372\s?\d{3}\s?\d{4}/, phone_number)
end
def test_ee_cell_phone
deterministically_verify -> { Faker::PhoneNumber.cell_phone[0] }, depth: 5 do |cell_phone_prefix|
assert_include @valid_cell_phone_prefixes, cell_phone_prefix
end
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_fi_locale.rb | test/test_fi_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestFiLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'fi-FI'
end
def teardown
Faker::Config.locale = nil
end
def test_fi_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.state
assert_match(/^\d{1,3}$/, Faker::Address.building_number)
assert_match(/^\d{5}$/, Faker::Address.postcode)
assert_equal('Suomi', Faker::Address.default_country)
end
def test_fi_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.male_first_name
end
def test_fi_invoice_methods
assert_kind_of String, Faker::Invoice.creditor_reference
assert_kind_of String, Faker::Invoice.reference
assert_kind_of String, Faker::Invoice.reference(ref: '515141803475128')
assert_equal('5151418034751285', Faker::Invoice.reference(ref: '515141803475128#'))
end
def test_fi_phone_number
assert_match(/0\d{2}[-\s]?\d{6}/, Faker::PhoneNumber.cell_phone)
assert_match(/\d{2,3}[\s-]?\d{5,6}/, Faker::PhoneNumber.phone_number)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_locale.rb | test/test_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
LoadedYaml = %w[en en-BORK].each_with_object({}) do |locale, h|
h[locale] = YAML.load_file(File.expand_path(File.dirname(__FILE__) + "/../lib/locales/#{locale}.yml"))[locale]['faker']
end
class TestLocale < Test::Unit::TestCase
def teardown
Faker::Config.locale = nil
end
def test_locale_separate_from_i18n
I18n.locale = :en
Faker::Config.locale = :de
assert_match(/\(0\d+\) \d+|\d+-\d+/, Faker::PhoneNumber.phone_number)
assert_match(//, Faker::Address.street_name)
Faker::Config.locale = :ru
assert_match(/([\da-z.-]+)\.([a-z.]{2,6})/, Faker::Internet.domain_name)
end
def test_configured_locale_translation
Faker::Config.locale = 'en-BORK'
assert_equal Faker::Base.translate('faker.lorem.words').first, LoadedYaml['en-BORK']['lorem']['words'].first
end
def test_locale_override_when_calling_translate
Faker::Config.locale = 'en-BORK'
assert_equal Faker::Base.translate('faker.separator', locale: :en), LoadedYaml['en']['separator']
end
def test_translation_fallback
Faker::Config.locale = 'en-BORK'
assert_nil LoadedYaml['en-BORK']['name']
assert_equal Faker::Base.translate('faker.separator'), LoadedYaml['en']['separator']
end
def test_translation_fallback_without_en_in_available_locales
I18n.available_locales -= [:en]
Faker::Config.locale = 'en-BORK'
assert_nil LoadedYaml['en-BORK']['name']
assert_equal Faker::Base.translate('faker.separator'), LoadedYaml['en']['separator']
ensure
I18n.available_locales += [:en]
end
def test_with_locale_does_not_fail_without_the_locale_in_available_locales
I18n.available_locales -= [:en]
Faker::Base.with_locale(:en) do
assert_equal Faker::Base.translate('faker.separator'), LoadedYaml['en']['separator']
end
ensure
I18n.available_locales += [:en]
end
def test_no_en_in_available_locales
I18n.available_locales -= [:en]
assert_kind_of String, Faker::Address.country
ensure
I18n.available_locales += [:en]
end
def test_with_locale_changes_locale_temporarily
Faker::Config.locale = 'en-BORK'
I18n.with_locale(:en) do
assert_equal Faker::Base.translate('faker.separator'), LoadedYaml['en']['separator']
end
assert_equal 'en-BORK', Faker::Config.locale
end
def test_regex
Faker::Config.locale = 'en-GB'
re = /[A-PR-UWYZ]([A-HK-Y][0-9][ABEHMNPRVWXY0-9]?|[0-9][ABCDEFGHJKPSTUW0-9]?) [0-9][ABD-HJLNP-UW-Z]{2}/
assert_match re, result = Faker::Address.postcode, "#{result} didn't match #{re}"
end
def test_available_locales
assert I18n.locale_available?('en-GB')
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_es_ar_locale.rb | test/test_es_ar_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEsArLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'es-AR'
@no_words_pattern = /(?u:\w{0})$/
@one_word_pattern = /(?u:\w+)/
@one_or_more_words_pattern = /(?u:(?:\w+\ )*\w+)/
@many_words_pattern = /(?u:(?:\w+\ )+\w+)/
@name_with_nickname_pattern = /(?u:(?:'*\w+'*\ )+(?:'*\w+'*))/
@compass_letter_pattern = /^[NEOS]{1,2}(?:p?[NEOS]{1,2})?$/
@compass_number_pattern = /^\d+(?:.\d\d?)?$/
end
def teardown
Faker::Config.locale = nil
end
# -- NAMES
def test_es_ar_male_first_name
assert_match @one_or_more_words_pattern, Faker::Name.male_first_name
end
def test_es_ar_female_first_name
assert_match @one_or_more_words_pattern, Faker::Name.female_first_name
end
def test_es_ar_neutral_first_name
assert_match @no_words_pattern, Faker::Name.neutral_first_name
end
def test_es_ar_last_name
assert_match @one_or_more_words_pattern, Faker::Name.last_name
end
def test_es_ar_prefix
assert_match(/(\w+\.)/u, Faker::Name.prefix)
end
def test_es_ar_suffix
assert_match(/(\w+\.?)/u, Faker::Name.suffix)
end
def test_es_ar_name
assert_match @many_words_pattern, Faker::Name.name
end
def test_es_ar_name_with_middle
assert_match @many_words_pattern, Faker::Name.name_with_middle
end
# -- ADDRESS
# -- -- CITY
def test_es_ar_city_prefix
assert_match @one_or_more_words_pattern, Faker::Address.city_prefix
end
def test_es_ar_city_suffix
assert_match @one_or_more_words_pattern, Faker::Address.city_suffix
end
def test_es_ar_city
assert_match @one_or_more_words_pattern, Faker::Address.city
end
# -- -- STATE
def test_es_ar_state
assert_match @one_or_more_words_pattern, Faker::Address.state
end
def test_es_ar_state_abbr
assert_match(/(\w+\.*)/u, Faker::Address.state_abbr)
end
# -- -- ADDRESS
def test_es_ar_building_number
assert_match(/(S\/N|\d{2,5})/u, Faker::Address.building_number)
end
def test_es_ar_secondary_address
assert_match(/(PB|PA|(Piso|UF N°)\s\d{1,2}|(Departamento|Depto.|Lote)\s\d{1,2}[A-Z]|Manzana\s[A-Z]\d)/u, Faker::Address.secondary_address)
end
def test_es_ar_street_suffix
assert_match @no_words_pattern, Faker::Address.street_suffix
end
def test_es_ar_street_name
assert_match @one_or_more_words_pattern, Faker::Address.street_name
end
def test_es_ar_street_address
assert_kind_of String, Faker::Address.street_address
end
def test_es_ar_postcode
assert_match(/(\d{4}|[A-Z]\d{4}[A-Z]{3})/u, Faker::Address.postcode)
end
def test_es_ar_postcode_by_state_abbreviation
assert_match(/(B\d{4}[A-Z]{3})/u, Faker::Address.postcode(state_abbreviation: 'BA'))
end
def test_es_ar_full_address
assert_kind_of String, Faker::Address.full_address
end
# -- -- COUNTRY
def test_es_ar_country
assert_match @one_or_more_words_pattern, Faker::Address.country
end
def test_es_ar_country_by_code
assert_match Faker::Address.country_by_code(code: 'NL'), 'Holanda'
end
def test_es_ar_country_name_to_code
assert_match Faker::Address.country_name_to_code(name: 'estados_unidos'), 'US'
end
def test_es_ar_default_country
assert Faker::Address.default_country, 'Argentina'
end
# -- FOOTBALL
def test_es_ar_football_team
assert_match @one_or_more_words_pattern, Faker::Sports::Football.team
end
def test_es_ar_football_player
assert_match @name_with_nickname_pattern, Faker::Sports::Football.player
end
def test_es_ar_football_coach
assert_match @name_with_nickname_pattern, Faker::Sports::Football.coach
end
def test_es_ar_football_competition
assert_match @one_or_more_words_pattern, Faker::Sports::Football.competition
end
def test_es_ar_football_position
assert_match @one_or_more_words_pattern, Faker::Sports::Football.position
end
# -- BASKETBALL
def test_es_ar_basketball_team
assert_match @one_or_more_words_pattern, Faker::Sports::Basketball.team
end
def test_es_ar_basketball_player
assert_match @name_with_nickname_pattern, Faker::Sports::Basketball.player
end
def test_es_ar_basketball_coach
assert_match @name_with_nickname_pattern, Faker::Sports::Basketball.coach
end
def test_es_ar_basketball_position
assert_match @one_or_more_words_pattern, Faker::Sports::Basketball.position
end
# -- TEAMS
def test_es_ar_team_name
assert_match @one_or_more_words_pattern, Faker::Team.name
end
def test_es_ar_team_sport
assert_match @one_or_more_words_pattern, Faker::Team.sport
end
# -- MILITARY
def test_es_ar_army_rank
assert_match @one_or_more_words_pattern, Faker::Military.army_rank
end
def test_es_ar_marines_rank
assert_match @no_words_pattern, Faker::Military.marines_rank
end
def test_es_ar_navy_rank
assert_match @one_or_more_words_pattern, Faker::Military.navy_rank
end
def test_es_ar_coast_guard_rank
assert_match @one_or_more_words_pattern, Faker::Military.coast_guard_rank
end
def test_es_ar_air_force_rank
assert_match @one_or_more_words_pattern, Faker::Military.air_force_rank
end
def test_es_ar_space_force_rank
assert_match @no_words_pattern, Faker::Military.space_force_rank
end
# -- COMPASS
def test_es_ar_cardinal
assert_match @one_word_pattern, Faker::Compass.cardinal
end
def test_es_ar_ordinal
assert_match @one_word_pattern, Faker::Compass.ordinal
end
def test_es_ar_half_wind
assert_match @one_word_pattern, Faker::Compass.half_wind
end
def test_es_ar_quarter_wind
assert_match(/^\w+ por el \w+$/u, Faker::Compass.quarter_wind)
end
def test_es_ar_direction
assert_match(/^(?:\w+|\w+ por el \w+|[\w-]+)$/u, Faker::Compass.direction)
end
def test_es_ar_abbreviation
assert_match @compass_letter_pattern, Faker::Compass.abbreviation
end
def test_es_ar_azimuth
assert_match @compass_number_pattern, Faker::Compass.azimuth
end
def test_es_ar_cardinal_abbreviation
assert_match @compass_letter_pattern, Faker::Compass.cardinal_abbreviation
end
def test_es_ar_ordinal_abbreviation
assert_match @compass_letter_pattern, Faker::Compass.ordinal_abbreviation
end
def test_es_ar_half_wind_abbreviation
assert_match @compass_letter_pattern, Faker::Compass.half_wind_abbreviation
end
def test_es_ar_quarter_wind_abbreviation
assert_match @compass_letter_pattern, Faker::Compass.quarter_wind_abbreviation
end
def test_es_ar_cardinal_azimuth
assert_match @compass_number_pattern, Faker::Compass.cardinal_azimuth
end
def test_es_ar_ordinal_azimuth
assert_match @compass_number_pattern, Faker::Compass.ordinal_azimuth
end
def test_es_ar_half_wind_azimuth
assert_match @compass_number_pattern, Faker::Compass.half_wind_azimuth
end
def test_es_ar_quarter_wind_azimuth
assert_match @compass_number_pattern, Faker::Compass.quarter_wind_azimuth
end
# -- PHONE NUMBERS
def test_es_ar_phone_number
assert_match(/^\((?:011|0(?:2|3)\d{2,3}|)\) (?:4|5|6)(?:\d{3} \d{4}|\d{2}-\d{4}|\d{5})$/u, Faker::PhoneNumber.phone_number)
end
def test_es_ar_cell_phone
assert_match(/^(?:11|(?:2|3)\d{2,3})(?:-| )(?:4|5|6|7)(?:\d{3}(?:-| )\d{4}|\d{2}(?:-| )\d{4}|\d{5})$/u, Faker::PhoneNumber.cell_phone)
end
def test_es_ar_country_code
assert_match(/\+54/u, Faker::PhoneNumber.country_code)
end
def test_es_ar_phone_number_with_country_code
assert_match(/^\+54 \((?:011|0(?:2|3)\d{2,3}|)\) (?:4|5|6)(?:\d{3} \d{4}|\d{2}-\d{4}|\d{5})$/u, Faker::PhoneNumber.phone_number_with_country_code)
end
def test_es_ar_cell_phone_with_country_code
assert_match(/^\+54 (?:11|(?:2|3)\d{2,3})(?:-| )(?:4|5|6|7)(?:\d{3}(?:-| )\d{4}|\d{2}(?:-| )\d{4}|\d{5})$/u, Faker::PhoneNumber.cell_phone_with_country_code)
end
def test_es_ar_cell_phone_in_e164
assert_match(/^\+54(?:11|(?:2|3)\d{2,3})(?:4|5|6|7)(?:\d{3}\d{4}|\d{2}\d{4}|\d{5})$/u, Faker::PhoneNumber.cell_phone_in_e164)
end
# -- BANK
def test_es_ar_bank_names
assert_match @one_or_more_words_pattern, Faker::Bank.name
end
# -- COLORS
def test_es_ar_color_names
assert_match @one_or_more_words_pattern, Faker::Color.color_name
end
# -- CURRENCIES
def test_es_ar_currency_names
assert_match @one_or_more_words_pattern, Faker::Currency.name
end
# -- NATIONS
def test_es_ar_nation_nationalities
assert_match @one_or_more_words_pattern, Faker::Nation.nationality
end
def test_es_ar_nation_languages
assert_match @one_or_more_words_pattern, Faker::Nation.language
end
def test_es_ar_nation_capital_city
assert_match @one_or_more_words_pattern, Faker::Nation.capital_city
end
def test_es_ar_national_sport
assert_match @one_or_more_words_pattern, Faker::Nation.national_sport
end
# -- COMPANY
def test_es_ar_company_name
assert_match @one_or_more_words_pattern, Faker::Company.name
end
def test_es_ar_company_suffix
assert_match @one_or_more_words_pattern, Faker::Company.suffix
end
def test_es_ar_company_industry
assert_match @one_or_more_words_pattern, Faker::Company.industry
end
def test_es_ar_company_bs
assert_match @one_or_more_words_pattern, Faker::Company.bs
end
def test_es_ar_company_type
assert_match @one_or_more_words_pattern, Faker::Company.type
end
def test_es_ar_company_profession
assert_match @one_or_more_words_pattern, Faker::Company.profession
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_lv_locale.rb | test/test_lv_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestLvLocale < Test::Unit::TestCase
def setup
@phone_prefixes = %w[51 52 53 54 55 56 57 58 59 61 62 63 64 65 66 67
68 69 71 72 73 74 75 76 77 78 79].sort
@cell_prefixes = %w[21 22 23 24 25 26 27 28 29].sort
@previous_locale = Faker::Config.locale
Faker::Config.locale = :lv
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_lv_phone_number
prefixes = (0..999).map { Faker::PhoneNumber.phone_number[0, 2] }.uniq.sort
assert_equal @phone_prefixes, prefixes
end
def test_lv_cell_phone
prefixes = (0..999).map { Faker::PhoneNumber.cell_phone[0, 2] }.uniq.sort
assert_equal @cell_prefixes, prefixes
end
def test_lv_address_methods
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
end
def test_lv_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of Array, Faker::Company.buzzwords
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_lv_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_lv_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ug_locale.rb | test/test_en_ug_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnUgLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-UG'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_ug_address_methods
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.city_names
assert_kind_of String, Faker::Address.district_names
assert_kind_of String, Faker::Address.regions
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.district
assert_kind_of String, Faker::Address.region
end
def test_en_ug_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_ug_name_methods
assert_kind_of String, Faker::Name.last_name
end
def test_validity_of_phone_number
validation_regex = /^((0)|(256)|(\+256))((39)|(41))\d{7}$/
assert_match(validation_regex, Faker::PhoneNumber.phone_number.delete(' '))
end
def test_validity_of_cell_phone
validation_regex = /^((0)|(256)|(\+256))((70)|(71)|(72)|(74)|(75)|(77)|(78)|(79))\d{7}$/
assert_match(validation_regex, Faker::PhoneNumber.cell_phone.delete(' '))
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_za_locale.rb | test/test_en_za_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnZaLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-ZA'
end
def teardown
Faker::Config.locale = nil
end
def test_en_za_address_methods
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.province
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
end
def test_en_za_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.type
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.company_names
end
def test_en_za_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_za_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ms_locale.rb | test/test_en_ms_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnMsLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-MS'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_ms_address_methods
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.province
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.street_title
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::PhoneNumber.cell_phone
assert_kind_of String, Faker::Bank.name
assert_equal('Malaysia', Faker::Address.default_country)
end
def test_en_ms_bank_methods
assert_kind_of String, Faker::Bank.name
end
def test_en_ms_name_methods
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.malay_male_first_name
assert_kind_of String, Faker::Name.malay_female_first_name
assert_kind_of String, Faker::Name.chinese_male_first_name
assert_kind_of String, Faker::Name.chinese_male_last_name
assert_kind_of String, Faker::Name.chinese_female_first_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_helper.rb | test/test_helper.rb | # frozen_string_literal: true
require 'simplecov'
require 'simplecov_json_formatter'
SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
SimpleCov.start do
add_filter ['.bundle', 'lib/extensions', 'test']
end
require_relative 'support/assert_not_english'
require_relative 'support/assert_email_regex'
require_relative 'support/deprecation'
require 'minitest/autorun'
require 'test/unit'
require 'rubygems'
require 'timecop'
require 'yaml'
YAML::ENGINE.yamler = 'psych' if defined? YAML::ENGINE
require File.expand_path("#{File.dirname(__FILE__)}/../lib/faker")
# deterministically_verify executes the test provided in the block successive
# times with the same deterministic_random seed.
# @param subject_proc [Proc] a proc object that returns the subject under test
# when called.
# @param depth [Integer] the depth of deterministic comparisons to run; the default value is 2.
# @param seed [Integer] A random number seed; Used to override the default value which is 42.
#
# @example
# deterministically_verify ->{ @tester.username('bo peep') } do |subject|
# assert subject.match(/(bo(_|\.)peep|peep(_|\.)bo)/)
# end
#
def deterministically_verify(subject_proc, depth: 2, seed: 42)
results = depth.times.map do
Faker::Config.stub :random, Random.new(seed) do
yield subject_proc.call.freeze
end
end
results.combination(2) { |(first, second)| assert_equal first, second }
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_seeding.rb | test/test_seeding.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestSeeding < Test::Unit::TestCase
def setup; end
def test_deterministic
Faker::Config.random = Random.new(5)
first_random = Faker::Number.number(digits: 100_000)
Faker::Config.random = Random.new(5)
second_random = Faker::Number.number(digits: 100_000)
Faker::Config.random = Random.new
Faker::Config.random = nil
third_random = Faker::Number.number(digits: 100_000)
assert_equal first_random, second_random
# Tiny chance this will fail randomly if the unseeded Random just so
# happen generates the same number as Random.new(5)
refute_equal first_random, third_random
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_default_locale.rb | test/test_default_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestDefaultLocale < Test::Unit::TestCase
def test_setting_default_locale
# if locale is not set, fallback is :en
assert_equal :en, Faker::Config.locale
# locale can be updated initially
# and it becomes the default value
# for new threads
Faker::Config.default_locale = :pt
assert_equal :pt, Faker::Config.locale
t1 = Thread.new do
# child thread has initial locale equal to
# latest locale set on main thread
# instead of the fallback value
assert_equal :pt, Faker::Config.locale
# child thread can set its own locale
Faker::Config.locale = :es
assert_equal :es, Faker::Config.locale
end
t1.join
# child thread won't change locale of other threads
assert_equal :pt, Faker::Config.locale
t2 = Thread.new do
# initial default locale is copied over to new thread
assert_equal :pt, Faker::Config.locale
Faker::Config.locale = :it
assert_equal :it, Faker::Config.locale
end
t2.join
assert_equal :pt, Faker::Config.locale
# setting this to reset the default locale for all tests
Faker::Config.default_locale = nil
assert_equal :en, Faker::Config.locale
end
def test_setting_default_locale_on_child_thread
# if locale is not set, fallback is :en
assert_equal :en, Faker::Config.locale
# locale can be updated initially
# and it becomes the default value
# for new threads
Faker::Config.default_locale = :pt
assert_equal :pt, Faker::Config.locale
t1 = Thread.new do
# child thread has initial locale equal to
# latest locale set on main thread
# instead of the fallback value
assert_equal :pt, Faker::Config.locale
# child thread can set the default locale
Faker::Config.default_locale = :es
assert_equal :es, Faker::Config.locale
end
t1.join
# all threads now will have the same default
assert_equal :es, Faker::Config.locale
t2 = Thread.new do
# initial default locale is copied over to new thread
assert_equal :es, Faker::Config.locale
Faker::Config.locale = :it
assert_equal :it, Faker::Config.locale
end
t2.join
assert_equal :es, Faker::Config.locale
# setting this to reset the default locale for all tests
Faker::Config.default_locale = nil
assert_equal :en, Faker::Config.locale
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_i18n_reload.rb | test/test_i18n_reload.rb | # frozen_string_literal: true
require 'test_helper'
require 'open3'
class TestI18nLoad < Test::Unit::TestCase
def test_faker_i18n
# run this code in a subshell to test require faker
# and proper initialization of i18n.
code = <<-RUBY
require 'bundler/inline'
require 'test/unit'
gemfile do
source 'https://rubygems.org'
gem 'i18n'
end
require 'i18n'
class TestI18nLoad < Test::Unit::TestCase
def test_faker_i18n
I18n.available_locales = [:en]
refute I18n.backend.initialized?
I18n.translate('doesnt matter just triggering a lookup')
assert I18n.backend.initialized?
assert require File.expand_path('#{File.dirname(__FILE__)}/../lib/faker')
assert Faker::Name.name
end
end
RUBY
cmd = %( ruby -e "#{code}" )
output, status = Open3.capture2e(cmd)
assert_equal(0, status, output)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ko_locale.rb | test/test_ko_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestKoLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'ko'
end
def teardown
Faker::Config.locale = nil
end
def test_ko_address_methods
assert_kind_of String, Faker::Address.postcode
assert_equal(5, Faker::Address.postcode.length)
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.default_country
assert_equal('대한민국', Faker::Address.default_country)
end
def test_ko_adjective_methods
assert_kind_of String, Faker::Adjective.positive
assert_kind_of String, Faker::Adjective.negative
end
def test_ko_animal_methods
assert_kind_of String, Faker::Creature::Animal.name
end
def test_ko_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_ko_commerce_methods
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Commerce.promotion_code
assert_kind_of String, Faker::Commerce.material
end
def test_ko_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.prefix
assert_kind_of String, Faker::Company.name
end
def test_ko_dessert_methods
assert_kind_of String, Faker::Dessert.variety
assert_kind_of String, Faker::Dessert.topping
assert_kind_of String, Faker::Dessert.flavor
end
def test_ko_emotion_methods
assert_kind_of String, Faker::Emotion.adjective
assert_kind_of String, Faker::Emotion.noun
end
def test_ko_food_methods
assert_kind_of String, Faker::Food.allergens
assert_kind_of String, Faker::Food.dish
assert_kind_of String, Faker::Food.ingredients
assert_kind_of String, Faker::Food.fruits
assert_kind_of String, Faker::Food.vegetables
end
def test_ko_games_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
assert_kind_of String, Faker::Games::Pokemon.location
assert_kind_of String, Faker::Games::Pokemon.move
end
def test_ko_gender_methods
assert_kind_of String, Faker::Gender.binary_type
assert_not_english(Faker::Gender.binary_type)
end
def test_ko_hobby_methods
assert_kind_of String, Faker::Hobby.activity
end
def test_ko_house_methods
assert_kind_of String, Faker::House.furniture
assert_kind_of String, Faker::House.room
end
def test_ko_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_ko_kpop_methods
assert_kind_of String, Faker::Kpop.boy_bands
assert_kind_of String, Faker::Kpop.girl_groups
assert_kind_of String, Faker::Kpop.solo
end
def test_ko_lorem_methods
assert_kind_of Array, Faker::Lorem.words
end
def test_ko_movie_methods
assert_kind_of String, Faker::Movie.title
end
def test_ko_name_methods
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_ko_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
end
def test_ko_space_methods
assert_kind_of String, Faker::Space.planet
assert_kind_of String, Faker::Space.galaxy
end
def test_ko_studio_ghibli_methods
assert_kind_of String, Faker::JapaneseMedia::StudioGhibli.character
assert_kind_of String, Faker::JapaneseMedia::StudioGhibli.movie
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_sg_locale.rb | test/test_en_sg_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnSgLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-SG'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_sg_address_methods
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.streets
assert_kind_of String, Faker::Address.street_address
assert_equal('Singapore', Faker::Address.default_country)
end
def test_en_sg_name_methods
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.male_english_name
assert_kind_of String, Faker::Name.female_english_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
end
def test_singapore_license_plate
assert_match(/^S[A-Z]{2}\d{1,4}[A-Z]{1}$/, Faker::Vehicle.singapore_license_plate)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_he_locale.rb | test/test_he_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestHeLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'he'
end
def teardown
Faker::Config.locale = nil
end
def test_he_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_equal('ישראל', Faker::Address.default_country)
end
def test_he_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_tr_locale.rb | test/test_tr_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestTRLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'tr'
end
def teardown
Faker::Config.locale = nil
end
def test_tr_address_fields
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.country
assert_equal('Turkey', Faker::Address.default_country)
end
def test_tr_book_fields
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.quote
end
def test_tr_internet_fields
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
assert_kind_of String, Faker::Internet.email
end
def test_tr_names
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_tr_phone_number_fields
assert_kind_of String, Faker::PhoneNumber.phone_number
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_pt_locale.rb | test/test_pt_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestPtLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'pt'
end
def teardown
Faker::Config.locale = nil
end
def test_pt_address_methods
assert_match(/^[[:word:]]+[.]? \d{1,3}$/, Faker::Address.secondary_address)
assert_match(/^\d{3,5}$/, Faker::Address.building_number)
assert_match(/^\d{4}$/, Faker::Address.postcode)
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.country
assert_equal('Portugal', Faker::Address.default_country)
end
def test_pt_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_pt_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.name_with_middle
end
def test_pt_phone_number
assert_match(/^(\+351)?[()\d\s-]+$/, Faker::PhoneNumber.phone_number)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_no_no_locale.rb | test/test_no_no_locale.rb | # frozen_string_literal: true
require File.expand_path("#{File.dirname(__FILE__)}/test_helper.rb")
class TestNoNOLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'no-NO'
end
def teardown
Faker::Config.locale = nil
end
def test_no_no_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_no_no_invoice_methods
assert_kind_of String, Faker::Invoice.creditor_reference
assert_kind_of String, Faker::Invoice.reference
assert_kind_of String, Faker::Invoice.reference(ref: '699027016279494093882102#')
assert_equal('6990270162794940938821025', Faker::Invoice.reference(ref: '699027016279494093882102#'))
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_de_locale.rb | test/test_de_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestDeLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'de'
end
def teardown
Faker::Config.locale = nil
end
def test_de_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.street_root
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.time_zone
assert_equal('Deutschland', Faker::Address.default_country)
end
def test_de_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
end
def test_de_chuck_norris_methods
assert_kind_of String, Faker::ChuckNorris.fact
end
def test_de_color_methods
assert_kind_of String, Faker::Color.color_name
end
def test_de_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.legal_form
assert_kind_of String, Faker::Company.name
end
def test_de_compass_methods
assert_kind_of String, Faker::Compass.direction
assert_kind_of String, Faker::Compass.cardinal
assert_kind_of String, Faker::Compass.ordinal
assert_kind_of String, Faker::Compass.half_wind
assert_kind_of String, Faker::Compass.quarter_wind
assert_kind_of String, Faker::Compass.abbreviation
assert_kind_of String, Faker::Compass.cardinal_abbreviation
assert_kind_of String, Faker::Compass.ordinal_abbreviation
assert_kind_of String, Faker::Compass.half_wind_abbreviation
assert_kind_of String, Faker::Compass.quarter_wind_abbreviation
assert_kind_of String, Faker::Compass.azimuth
assert_kind_of String, Faker::Compass.cardinal_azimuth
assert_kind_of String, Faker::Compass.ordinal_azimuth
assert_kind_of String, Faker::Compass.half_wind_azimuth
assert_kind_of String, Faker::Compass.quarter_wind_azimuth
end
def test_de_commerce_methods
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
end
def test_de_food_methods
assert_kind_of String, Faker::Food.ingredient
assert_kind_of String, Faker::Food.spice
assert_kind_of String, Faker::Food.measurement
assert_kind_of String, Faker::Food.measurement_sizes
end
def test_de_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_de_lorem_methods
assert_kind_of Array, Faker::Lorem.words
end
def test_de_hipster_methods
assert_kind_of Array, Faker::Hipster.words
end
def test_de_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.nobility_title_prefix
assert_kind_of String, Faker::Name.nobility_title
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_de_music_methods
assert_kind_of String, Faker::Music.instrument
end
def test_de_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
end
def test_de_simpsons_methods
assert_kind_of String, Faker::TvShows::Simpsons.character
end
def test_de_space_methods
assert_kind_of String, Faker::Space.planet
assert_kind_of String, Faker::Space.moon
assert_kind_of String, Faker::Space.nebula
assert_kind_of String, Faker::Space.star_cluster
assert_kind_of String, Faker::Space.constellation
assert_kind_of String, Faker::Space.agency
assert_kind_of String, Faker::Space.galaxy
assert_kind_of String, Faker::Space.star
assert_kind_of String, Faker::Space.distance_measurement
end
def test_de_cell_phone_countrycode
mobile = Faker::PhoneNumber.cell_phone_with_country_code.gsub(/\D/, '')
assert_match(/^(0|49)/, mobile)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_fr_ca_locale.rb | test/test_fr_ca_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestFrCaLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
@standard_wordlist = I18n.translate('faker.lorem.words')
@complete_wordlist =
@standard_wordlist + I18n.translate('faker.lorem.supplemental')
Faker::Config.locale = 'fr-CA'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_fr_ca_address_methods
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_match(/^\d+$/, Faker::Address.building_number)
assert_equal('Canada', Faker::Address.default_country)
end
def test_fr_ca_book_methods
assert_kind_of String, Faker::Book.title
assert_kind_of String, Faker::Book.author
assert_kind_of String, Faker::Book.publisher
assert_kind_of String, Faker::Book.quote
end
def test_fr_ca_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_fr_ca_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_fr_ca_lorem_methods
assert_kind_of String, Faker::Lorem.word
assert Faker::Lorem.words(number: 1000)
assert Faker::Lorem.words(number: 10_000, supplemental: true)
end
def test_fr_ca_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_fr_ca_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.area_code
assert_kind_of String, Faker::PhoneNumber.exchange_code
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_kind_of String, Faker::PhoneNumber.cell_phone
end
def test_fr_ca_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
assert_kind_of String, Faker::Games::Pokemon.location
assert_kind_of String, Faker::Games::Pokemon.move
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_pl_locale.rb | test/test_pl_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestPlLocale < Test::Unit::TestCase
def setup
@phone_prefixes = %w[12 13 14 15 16 17 18 22 23 24 25 29 32 33 34 41 42 43 44 46 48 52 54 55 56 58 59 61 62 63 65 67 68 71 74 75 76 77 81 82 83 84 85 86 87 89 91 94 95].sort
@cell_prefixes = %w[50 51 53 57 60 66 69 72 73 78 79 88].sort
@previous_locale = Faker::Config.locale
Faker::Config.locale = :pl
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_pl_names
names = Faker::Base.fetch_all('name.first_name') + Faker::Base.fetch_all('name.last_name')
names.each { |name| assert_match(/([\wĄąĆćĘꣳÓ󌜯żŹź]+\.? ?){2,3}/, name) }
end
def test_pl_phone_number
prefixes = (0..999).map { Faker::PhoneNumber.phone_number[0, 2] }.uniq.sort
assert_equal @phone_prefixes, prefixes
end
def test_pl_cell_phone
prefixes = (0..999).map { Faker::PhoneNumber.cell_phone[0, 2] }.uniq.sort
assert_equal @cell_prefixes, prefixes
end
def test_pl_address_methods
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_prefix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_equal('Polska', Faker::Address.default_country)
end
def test_pl_coin_methods
assert_kind_of String, Faker::Coin.flip
end
def test_pl_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of Array, Faker::Company.buzzwords
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_pl_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_pl_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.name_with_middle
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_flexible.rb | test/test_flexible.rb | # frozen_string_literal: true
require_relative 'test_helper'
module Faker
class Foodie < Base
flexible :chow
end
end
class TestFlexible < Test::Unit::TestCase
def setup
@old_locales = I18n.config.available_locales
I18n.config.available_locales += %i[xx home kindergarden work]
I18n.backend.store_translations(:xx, faker: { chow: { yummie: %i[fudge chocolate caramel], taste: 'delicious' } })
I18n.backend.store_translations(:home, faker: { address: { birthplace: %i[bed hospital airplane] } })
I18n.backend.store_translations(:kindergarden, faker: { name: { girls_name: %i[alice cheryl tatiana] } })
I18n.backend.store_translations(:work, faker: { company: { do_stuff: %i[work work work] } })
end
def teardown
I18n.config.available_locales = @old_locales
end
def test_flexible_multiple_values
I18n.with_locale(:xx) do
assert_includes %i[fudge chocolate caramel], Faker::Foodie.yummie
end
end
def test_flexible_single_value
I18n.with_locale(:xx) do
assert_equal 'delicious', Faker::Foodie.taste
end
end
def test_flexible_fallbacks_to_english
I18n.backend.store_translations(:en, faker: { chow: { taste: 'superdelicious' } })
I18n.with_locale(:home) do
assert_equal 'superdelicious', Faker::Foodie.taste
end
I18n.reload!
end
def test_raises_missing_translation_data_when_not_even_english_defined
I18n.with_locale(:xx) do
assert_raise(I18n::MissingTranslationData) do
Faker::Foodie.eeew
end
end
end
def test_address_is_flexible
I18n.with_locale(:home) do
assert_includes %i[bed hospital airplane], Faker::Address.birthplace
end
end
def test_name_is_flexible
I18n.with_locale(:kindergarden) do
assert_includes %i[alice cheryl tatiana], Faker::Name.girls_name
end
end
def test_company_is_flexible
I18n.with_locale(:work) do
assert_equal(:work, Faker::Company.do_stuff)
end
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_au_locale.rb | test/test_en_au_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnAuLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-AU'
end
def teardown
Faker::Config.locale = nil
end
def test_en_au_address_methods
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.default_country
end
def test_en_au_company_methods
assert_kind_of String, Faker::Company.suffix
end
def test_en_au_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.name_with_middle
end
def test_aussie_mobiles_start_with_04
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '0', mobile[0]
assert_equal '4', mobile[1]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_th_locale.rb | test/test_th_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestThLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'th'
end
def teardown
Faker::Config.locale = nil
end
def test_th_name_methods
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_ca_locale.rb | test/test_en_ca_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnCaLocale < Test::Unit::TestCase
def setup
@previous_locale = Faker::Config.locale
Faker::Config.locale = 'en-CA'
end
def teardown
Faker::Config.locale = @previous_locale
end
def test_en_ca_address_methods
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.default_country
assert_equal 'Canada', Faker::Address.default_country
expected = /[A-VX-Y][0-9][A-CEJ-NPR-TV-Z] ?[0-9][A-CEJ-NPR-TV-Z][0-9]/
assert_match(expected, Faker::Address.postcode)
end
def test_en_ca_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_ca_subscriber_number_method
assert_kind_of String, Faker::PhoneNumber.subscriber_number
assert_equal(4, Faker::PhoneNumber.subscriber_number.length)
assert_equal(10, Faker::PhoneNumber.subscriber_number(length: 10).length)
assert_equal Faker::PhoneNumber.method(:extension), Faker::PhoneNumber.method(:subscriber_number)
end
def test_en_ca_phone_methods
assert_kind_of String, Faker::PhoneNumber.area_code
assert_kind_of Integer, Faker::PhoneNumber.area_code.to_i
assert_equal(3, Faker::PhoneNumber.area_code.length)
assert_kind_of String, Faker::PhoneNumber.exchange_code
assert_kind_of Integer, Faker::PhoneNumber.exchange_code.to_i
assert_equal(3, Faker::PhoneNumber.exchange_code.length)
assert_equal('+1', Faker::PhoneNumber.country_code)
assert_kind_of(String, Faker::PhoneNumber.area_code)
assert_kind_of(String, Faker::PhoneNumber.exchange_code)
end
def test_validity_of_phone_method_output
# got the following regex from http://stackoverflow.com/a/123666/1210055 as an expression of the NANP standard.
ca_number_validation_regex = /^(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?$/
assert_match(ca_number_validation_regex, Faker::PhoneNumber.phone_number)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ca_cat_locale.rb | test/test_ca_cat_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestCaCatLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'ca-CAT'
end
def teardown
Faker::Config.locale = nil
end
def test_ca_cat_address_methods
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.province
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_equal 'Catalunya', Faker::Address.default_country
end
def test_ca_cat_phone_numbers_start_with_9
mobile = Faker::PhoneNumber.phone_number.gsub(/\D/, '')
assert_equal '9', mobile[0]
end
def test_ca_cat_cell_numbers_start_with_6
mobile = Faker::PhoneNumber.cell_phone.gsub(/\D/, '')
assert_equal '6', mobile[0]
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_sk_locale.rb | test/test_sk_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestSKLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'sk'
end
def teardown
Faker::Config.locale = nil
end
def test_sk_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.secondary_address
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.state_abbr
assert_kind_of String, Faker::Address.time_zone
assert_kind_of String, Faker::Address.city_name
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_equal 'Slovensko', Faker::Address.default_country
end
def test_sk_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.buzzword
assert_kind_of String, Faker::Company.bs
assert_kind_of String, Faker::Company.name
end
def test_sk_internet_methods
assert_kind_of String, Faker::Internet.email
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_sk_name_methods
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.last_name
end
def test_sk_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_pt_br_locale.rb | test/test_pt_br_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestPtBrLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'pt-BR'
end
def teardown
Faker::Config.locale = nil
end
def test_pt_br_address_methods
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.state_abbr
assert_match(/^[A-Z]{2}$/, Faker::Address.state_abbr)
assert_kind_of String, Faker::Address.country
assert_kind_of String, Faker::Address.building_number
assert_match(/^([0-9]+)|(s\/n)$/, Faker::Address.building_number)
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.secondary_address
assert_match(/^[a-zA-Z.]+\s[0-9]+$/, Faker::Address.secondary_address)
assert_kind_of String, Faker::Address.postcode
assert_match(/^[0-9]{5}-[0-9]{3}$/, Faker::Address.postcode)
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert Faker::Address.default_country, 'Brasil'
end
def test_pt_br_phone_methods
assert_equal('+55', Faker::PhoneNumber.country_code)
end
def test_pt_br_color_methods
assert_kind_of String, Faker::Color.hex_color
assert_match(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/, Faker::Color.hex_color)
assert_kind_of String, Faker::Color.color_name
assert_kind_of Array, Faker::Color.rgb_color
Faker::Color.rgb_color.each do |value|
assert value.between?(0, 255)
end
assert_kind_of Array, Faker::Color.hsl_color
hue = Faker::Color.hsl_color[0]
assert hue.between?(0, 360)
Faker::Color.hsl_color[1..2].each do |value|
assert value.between?(0, 1)
end
assert_kind_of Array, Faker::Color.hsla_color
assert_kind_of Array, Faker::Color.hsl_color
hue = Faker::Color.hsl_color[0]
assert hue.between?(0, 360)
Faker::Color.hsl_color[1..3].each do |value|
assert value.between?(0, 1)
end
end
def test_pt_br_company_methods
assert_kind_of String, Faker::Company.name
assert_kind_of String, Faker::Company.suffix
end
def test_pt_br_commerce_methods
assert_kind_of String, Faker::Commerce.color
assert_kind_of String, Faker::Commerce.department
assert_kind_of String, Faker::Commerce.product_name
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_pt_br_food_methods
assert_kind_of String, Faker::Food.ingredient
assert_kind_of String, Faker::Food.spice
assert_kind_of String, Faker::Food.measurement
end
def test_pt_br_internet_methods
deterministically_verify -> { Faker::Internet.email } do |result|
name, domain = result.split('@')
domain_name, domain_suffix = domain.split('.')
assert_kind_of String, name
assert_kind_of String, domain_name
assert_includes(%w[example test], domain_suffix)
assert_match(/^[a-z0-9._-]+@[a-z0-9]+.[a-z]+.([a-z]+)?$/i, result)
end
end
def test_pt_br_job_methods
assert_kind_of String, Faker::Job.field
assert_kind_of String, Faker::Job.seniority
assert_kind_of String, Faker::Job.position
assert_kind_of String, Faker::Job.key_skills
assert_kind_of String, Faker::Job.employment_type
assert_kind_of String, Faker::Job.education_level
assert_kind_of String, Faker::Job.title
end
def test_pt_br_name_methods
assert_kind_of String, Faker::Name.prefix
assert_kind_of String, Faker::Name.suffix
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.middle_name
assert_kind_of String, Faker::Name.name_with_middle
assert_kind_of String, Faker::Name.male_first_name
assert_kind_of String, Faker::Name.female_first_name
assert_kind_of String, Faker::Name.name
assert_match(/[A-Z]{3}/, Faker::Name.initials)
assert_match(/[A-Z]{2}/, Faker::Name.initials(number: 2))
end
def test_pt_br_team_methods
assert_kind_of String, Faker::Team.main_teams
assert_kind_of String, Faker::Team.prefix
assert_kind_of String, Faker::Team.gentile
assert_kind_of String, Faker::Team.name
assert_kind_of String, Faker::Team.sport
end
def test_pt_br_university_methods
assert_kind_of String, Faker::University.prefix
assert_kind_of String, Faker::University.region
assert_kind_of String, Faker::University.suffix
assert_kind_of String, Faker::University.name
end
def test_pt_br_vehicle_methods
assert_kind_of String, Faker::Vehicle.license_plate
assert_match(/(^[A-Z]{3}-[0-9]{4})|([A-Z]{3}[0-9]{1}[A-Z][0-9]{2})|([A-Z]{3}[0-9]{2}[A-Z][0-9])/, Faker::Vehicle.license_plate)
assert_kind_of String, Faker::Vehicle.license_plate(state_abbreviation: 'RJ')
assert_match(/^[A-Z]{3}-[0-9]{4}/, Faker::Vehicle.license_plate(state_abbreviation: 'RJ'))
end
def test_pt_br_gender_methods
assert_kind_of String, Faker::Gender.type
assert_includes(['Feminino', 'Masculino', 'Não Binário', 'Agênero', 'Gênero Fluido', 'Gênero queer', 'Bigênero', 'Poligênero'], Faker::Gender.type)
assert_kind_of String, Faker::Gender.binary_type
assert_includes(%w[Feminino Masculino], Faker::Gender.binary_type)
end
def test_pt_br_animal_methods
assert_kind_of String, Faker::Creature::Animal.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_zh_cn_locale.rb | test/test_zh_cn_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestZhCnLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'zh-CN'
end
def teardown
Faker::Config.locale = nil
end
def test_zh_cn_address_methods
assert_kind_of String, Faker::Address.city_prefix
assert_kind_of String, Faker::Address.city_suffix
assert_kind_of String, Faker::Address.building_number
assert_kind_of String, Faker::Address.street_suffix
assert_kind_of String, Faker::Address.postcode
assert_kind_of String, Faker::Address.state
assert_kind_of String, Faker::Address.city
assert_kind_of String, Faker::Address.street_name
assert_kind_of String, Faker::Address.street_address
assert_kind_of String, Faker::Address.default_country
assert_equal('中国', Faker::Address.default_country)
end
def test_zh_cn_name_methods
assert_kind_of String, Faker::Name.last_name
assert_kind_of String, Faker::Name.first_name
assert_kind_of String, Faker::Name.name
assert_kind_of String, Faker::Name.name_with_middle
assert_no_match(/\s/, Faker::Name.name_with_middle)
end
def test_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.phone_number
cn_cell_phone_validation_regex = /^1(3[0-9]|4[57]|5[0-35-9]|7[0-35-8]|8[0-9])\d{8}$/
assert_match(cn_cell_phone_validation_regex, Faker::PhoneNumber.cell_phone)
end
def test_zh_cn_university_methods
assert_kind_of String, Faker::University.prefix
assert_kind_of String, Faker::University.suffix
assert_kind_of String, Faker::University.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_en_us_locale.rb | test/test_en_us_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestEnUsLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'en-US'
end
def teardown
Faker::Config.locale = nil
end
def test_en_us_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_en_us_address_methods
assert_kind_of String, Faker::Address.full_address
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.full_address
end
def test_en_us_subscriber_number_method
assert_kind_of String, Faker::PhoneNumber.subscriber_number
assert_equal(4, Faker::PhoneNumber.subscriber_number.length)
assert_equal(10, Faker::PhoneNumber.subscriber_number(length: 10).length)
assert_equal Faker::PhoneNumber.method(:extension), Faker::PhoneNumber.method(:subscriber_number)
end
def test_en_us_phone_methods_with_en_us_locale
assert_kind_of String, Faker::PhoneNumber.area_code
assert_kind_of Integer, Faker::PhoneNumber.area_code.to_i
assert_equal(3, Faker::PhoneNumber.area_code.length)
assert_kind_of String, Faker::PhoneNumber.exchange_code
assert_kind_of Integer, Faker::PhoneNumber.exchange_code.to_i
assert_equal(3, Faker::PhoneNumber.exchange_code.length)
end
def test_validity_of_phone_method_output
# got the following regex from http://stackoverflow.com/a/123666/1210055 as an expression of the NANP standard.
us_number_validation_regex = /^(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?$/
assert_match(us_number_validation_regex, Faker::PhoneNumber.phone_number)
end
def test_en_us_invalid_state_raises_exception
assert_raise(I18n::MissingTranslationData) { Faker::Address.zip_code(state_abbreviation: 'NA') }
end
def test_en_us_zip_codes_match_state
state_abbr = 'AZ'
expected = /^850\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
# disjointed ranges for these states
# http://www.fincen.gov/forms/files/us_state_territory_zip_codes.pdf
state_abbr = 'AR'
expected = /^717\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
state_abbr = 'GA'
expected = /^301\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
state_abbr = 'MA'
expected = /^026\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
state_abbr = 'NY'
expected = /^122\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
state_abbr = 'TX'
expected = /^798\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
state_abbr = 'VA'
expected = /^222\d\d$/
assert_match(expected, Faker::Address.zip_code(state_abbreviation: state_abbr))
end
def test_en_us_valid_id_number
id_num = Faker::IdNumber.valid
assert(Faker::IdNumber::INVALID_SSN.none? { |regex| id_num =~ regex })
end
def test_en_us_invalid_id_number
id_num = Faker::IdNumber.invalid
assert(Faker::IdNumber::INVALID_SSN.any? { |regex| id_num =~ regex })
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_de_ch_locale.rb | test/test_de_ch_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestDeChLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'de-CH'
end
def teardown
Faker::Config.locale = nil
end
def test_de_ch_address_methods
assert_kind_of String, Faker::Address.country_code
assert_kind_of String, Faker::Address.default_country
assert_kind_of String, Faker::Address.postcode
assert_equal('Schweiz', Faker::Address.default_country)
end
def test_de_ch_company_methods
assert_kind_of String, Faker::Company.suffix
assert_kind_of String, Faker::Company.name
end
def test_de_ch_internet_methods
assert_kind_of String, Faker::Internet.domain_suffix
end
def test_de_ch_mountain_methods
assert_kind_of String, Faker::Mountain.name
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/test_ja_locale.rb | test/test_ja_locale.rb | # frozen_string_literal: true
require_relative 'test_helper'
class TestJaLocale < Test::Unit::TestCase
def setup
Faker::Config.locale = 'ja'
end
def teardown
Faker::Config.locale = nil
end
def test_ja_address_methods
assert_kind_of String, Faker::Address.postcode
# Added Actual Japanese Zipcodes in lib/locals/ja.yml
assert_match(/\A\d{3}-\d{4}\z/, Faker::Address.postcode)
assert_not_english(Faker::Address.postcode)
assert_kind_of String, Faker::Address.state
assert_not_english(Faker::Address.state)
assert_kind_of String, Faker::Address.state_abbr
assert_not_english(Faker::Address.state_abbr)
assert_kind_of String, Faker::Address.city_prefix
assert_not_english(Faker::Address.city_prefix)
assert_kind_of String, Faker::Address.city_suffix
assert_not_english(Faker::Address.city_suffix)
assert_kind_of String, Faker::Address.city
assert_not_english(Faker::Address.city)
assert_kind_of String, Faker::Address.street_name
assert_not_english(Faker::Address.street_name)
end
def test_ja_adjective_methods
assert_kind_of String, Faker::Adjective.positive
assert_not_english(Faker::Adjective.positive)
assert_kind_of String, Faker::Adjective.negative
assert_not_english(Faker::Adjective.negative)
end
def test_ja_ancient_methods
assert_kind_of String, Faker::Ancient.god
assert_not_english(Faker::Ancient.god)
end
def test_ja_artist_method
assert_kind_of String, Faker::Artist.name
assert_not_english(Faker::Artist.name)
end
def test_ja_cat_methods
assert_kind_of String, Faker::Creature::Cat.breed
assert_not_match(/[a-zA-Z]/, Faker::Creature::Cat.breed)
end
def test_ja_color_methods
assert_kind_of String, Faker::Color.color_name
assert_not_english(Faker::Color.color_name)
end
def test_ja_book_methods
assert_kind_of String, Faker::Book.title
assert_not_english(Faker::Book.title)
assert_kind_of String, Faker::Book.author
assert_not_english(Faker::Book.author)
assert_kind_of String, Faker::Book.publisher
assert_not_english(Faker::Book.publisher)
assert_kind_of String, Faker::Book.genre
assert_not_english(Faker::Book.genre)
end
def test_ja_coffee_methods
assert_kind_of String, Faker::Coffee.country
assert_not_english(Faker::Coffee.country)
end
def test_ja_commerce_methods
assert_kind_of String, Faker::Commerce.department
assert_not_english(Faker::Commerce.department)
assert_kind_of String, Faker::Commerce.product_name
assert_not_english(Faker::Commerce.product_name)
assert_kind_of String, Faker::Commerce.promotion_code
assert_not_english(Faker::Commerce.promotion_code)
end
def test_ja_company_methods
assert_kind_of String, Faker::Company.suffix
assert_not_english(Faker::Company.suffix)
assert_kind_of String, Faker::Company.category
assert_not_english(Faker::Company.category)
assert_kind_of String, Faker::Company.name
assert_not_english(Faker::Company.name)
end
def test_ja_dog_methods
assert_kind_of String, Faker::Creature::Dog.breed
assert_not_match(/[a-zA-Z]/, Faker::Creature::Dog.breed)
end
def test_ja_emotion_methods
assert_kind_of String, Faker::Emotion.noun
assert_not_english(Faker::Emotion.noun)
assert_kind_of String, Faker::Emotion.adjective
assert_not_english(Faker::Emotion.adjective)
end
def test_ja_food_methods
assert_kind_of String, Faker::Food.sushi
assert_not_english(Faker::Food.sushi)
end
def test_ja_gender_methods
assert_kind_of String, Faker::Gender.binary_type
assert_not_english(Faker::Gender.binary_type)
end
def test_ja_lorem_methods
assert_kind_of Array, Faker::Lorem.words
assert Faker::Lorem.words(number: 1000)
assert Faker::Lorem.words(number: 10_000, supplemental: true)
assert_not_match(/ /, Faker::Lorem.paragraph)
end
def test_ja_name_methods
assert_kind_of String, Faker::Name.last_name
assert_not_english(Faker::Name.last_name)
assert_kind_of String, Faker::Name.first_name
assert_not_english(Faker::Name.first_name)
assert_kind_of String, Faker::Name.name
assert_not_english(Faker::Name.name)
assert_kind_of String, Faker::Name.name_with_middle
assert_not_english(Faker::Name.name_with_middle)
end
def test_ja_phone_number_methods
assert_kind_of String, Faker::PhoneNumber.cell_phone
assert_not_english(Faker::PhoneNumber.cell_phone)
assert_kind_of String, Faker::PhoneNumber.phone_number
assert_not_english(Faker::PhoneNumber.phone_number)
end
def test_ja_overwatch_methods
assert_kind_of String, Faker::Games::Overwatch.hero
hero = Faker::Games::Overwatch.hero
assert_not_english(hero) unless hero == 'D.Va'
end
def test_ja_pokemon_methods
assert_kind_of String, Faker::Games::Pokemon.name
assert_not_english(Faker::Games::Pokemon.name)
assert_kind_of String, Faker::Games::Pokemon.location
assert_not_english(Faker::Games::Pokemon.location)
assert_kind_of String, Faker::Games::Pokemon.move
assert_not_english(Faker::Games::Pokemon.move)
end
def test_ja_supermario_methods
assert_kind_of String, Faker::Games::SuperMario.character
assert_not_english(Faker::Games::SuperMario.character)
assert_kind_of String, Faker::Games::SuperMario.game
assert_not_english(Faker::Games::SuperMario.game)
assert_kind_of String, Faker::Games::SuperMario.location
assert_not_english(Faker::Games::SuperMario.location)
end
def test_ja_touhou_methods
assert_kind_of String, Faker::Games::Touhou.game
assert_not_english(Faker::Games::Touhou.game)
assert_kind_of String, Faker::Games::Touhou.character
assert_not_english(Faker::Games::Touhou.character)
assert_kind_of String, Faker::Games::Touhou.location
assert_not_english(Faker::Games::Touhou.location)
assert_kind_of String, Faker::Games::Touhou.spell_card
assert_not_english(Faker::Games::Touhou.spell_card)
assert_kind_of String, Faker::Games::Touhou.song
assert_not_english(Faker::Games::Touhou.song)
end
def test_ja_zelda_methods
assert_kind_of String, Faker::Games::Zelda.game
assert_not_english(Faker::Games::Zelda.game)
end
def test_ja_restaurant_methods
assert_kind_of String, Faker::Restaurant.name
assert_not_english(Faker::Restaurant.name)
assert_kind_of String, Faker::Restaurant.type
assert_not_english(Faker::Restaurant.type)
end
def test_ja_space_methods
assert_kind_of String, Faker::Space.planet
assert_not_english(Faker::Space.planet)
assert_kind_of String, Faker::Space.galaxy
end
def test_ja_studio_ghibli_methods
assert_kind_of String, Faker::JapaneseMedia::StudioGhibli.character
assert_not_english(Faker::JapaneseMedia::StudioGhibli.character)
assert_kind_of String, Faker::JapaneseMedia::StudioGhibli.quote
assert_not_english(Faker::JapaneseMedia::StudioGhibli.quote)
assert_kind_of String, Faker::JapaneseMedia::StudioGhibli.movie
assert_not_english(Faker::JapaneseMedia::StudioGhibli.movie)
end
def test_ja_naruto_methods
assert_kind_of String, Faker::JapaneseMedia::Naruto.character
assert_not_english(Faker::JapaneseMedia::Naruto.character)
assert_kind_of String, Faker::JapaneseMedia::Naruto.village
assert_not_english(Faker::JapaneseMedia::Naruto.village)
assert_kind_of String, Faker::JapaneseMedia::Naruto.eye
assert_not_english(Faker::JapaneseMedia::Naruto.eye)
assert_kind_of String, Faker::JapaneseMedia::Naruto.demon
assert_not_english(Faker::JapaneseMedia::Naruto.demon)
end
def test_ja_subscription_methods
assert_kind_of String, Faker::Subscription.plan
assert_not_english(Faker::Subscription.plan)
assert_kind_of String, Faker::Subscription.status
assert_not_english(Faker::Subscription.status)
assert_kind_of String, Faker::Subscription.payment_method
assert Array.new(10) { Faker::Subscription.payment_method }.any? { |word| !word.match?(/[a-zA-Z]/) }
assert_kind_of String, Faker::Subscription.subscription_term
assert_not_english(Faker::Subscription.subscription_term)
assert_kind_of String, Faker::Subscription.payment_term
assert_not_english(Faker::Subscription.payment_term)
end
def test_ja_university_methods
assert_kind_of String, Faker::University.prefix
assert_not_english(Faker::University.prefix)
assert_kind_of String, Faker::University.suffix
assert_not_english(Faker::University.suffix)
assert_kind_of String, Faker::University.name
assert_not_english(Faker::University.name)
end
def test_ja_sport_methods
assert_kind_of String, Faker::Sport.sport
assert_not_english(Faker::Sport.sport)
assert_kind_of String, Faker::Sport.summer_olympics_sport
assert_not_english(Faker::Sport.summer_olympics_sport)
assert_kind_of String, Faker::Sport.winter_olympics_sport
assert_not_english(Faker::Sport.winter_olympics_sport)
assert_kind_of String, Faker::Sport.summer_paralympics_sport
assert_not_english(Faker::Sport.summer_paralympics_sport)
assert_kind_of String, Faker::Sport.winter_paralympics_sport
assert_not_english(Faker::Sport.winter_paralympics_sport)
assert_kind_of String, Faker::Sport.ancient_olympics_sport
assert_not_english(Faker::Sport.ancient_olympics_sport)
assert_kind_of String, Faker::Sport.unusual_sport
assert_not_english(Faker::Sport.unusual_sport)
end
def test_ja_football_methods
# The translation of "team" includes alphabets, so we cannot use assert_not_english for assertion.
# Example: "FCバルセロナ" (FC Barcelona)
assert_kind_of String, Faker::Sports::Football.team
assert_kind_of String, Faker::Sports::Football.player
assert_not_english(Faker::Sports::Football.player)
assert_kind_of String, Faker::Sports::Football.coach
assert_not_english(Faker::Sports::Football.coach)
# The translation of "competition" includes alphabets, so we cannot use assert_not_english for assertion.
# Example: "UEFAチャンピオンズリーグ" (UEFA Champions League)
assert_kind_of String, Faker::Sports::Football.competition
assert_kind_of String, Faker::Sports::Football.position
assert_not_english(Faker::Sports::Football.position)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/support/deprecation.rb | test/support/deprecation.rb | # frozen_string_literal: true
# Based on Rails Testing Deprecator
# https://github.com/rails/rails/blob/main/activesupport/lib/active_support/testing/deprecation.rb
# Asserts that a matching deprecation warning was emitted during the execution of the yielded block.
#
# assert_deprecated do
# DeprecatedGenerator.generate
# end
#
def assert_deprecated(&block)
warning = with_captured_stdout(&block)
result = yield block
refute_predicate warning, :empty?, 'Expected a deprecation warning within the block but received none'
result
end
# Asserts that no deprecation warnings are emitted during the execution of the yielded block.
#
# assert_not_deprecated do
# Faker::Internet.email
# end
def assert_not_deprecated(&block)
warning = with_captured_stdout(&block)
result = yield block
assert_predicate warning, :empty?, "Expected no deprecation warning within the block but received a deprecation: #{warning}"
result
end
def with_captured_stdout(&block)
original_stdout = $stdout
$stdout = StringIO.new
yield block
$stdout.string
ensure
$stdout = original_stdout
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/support/assert_email_regex.rb | test/support/assert_email_regex.rb | # frozen_string_literal: true
def assert_email_regex(first_name, last_name, email)
sanitized_first_name = first_name&.gsub("'", '')
sanitized_last_name = last_name&.gsub("'", '')
regex = email_regex(sanitized_first_name, sanitized_last_name)
assert_match(regex, email)
end
def email_regex(first_name, last_name)
/(#{first_name}([_.])?#{last_name}|#{last_name}([_.])?#{first_name})@(.*)\.(example|test)/i
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/support/assert_not_english.rb | test/support/assert_not_english.rb | # frozen_string_literal: true
def assert_not_english(word)
assert_not_match(/[a-zA-Z]/, word)
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/helpers/test_faker_deprecator.rb | test/helpers/test_faker_deprecator.rb | # frozen_string_literal: true
require_relative '../test_helper'
class TestFakerDeprecation < Test::Unit::TestCase
def test_using_a_deprecated_generator_returns_a_warning_message
assert_deprecated do
Faker::Dogs.say
end
assert_equal 'meow', Faker::Dogs.say
end
def test_using_a_non_deprecated_generator_does_not_return_a_warning_message
assert_not_deprecated do
Faker::Cats.say
end
assert_equal 'meow', Faker::Cats.say
end
def test_testing_a_deprecated_generator_with_skip_warning_does_not_return_a_warning_message
actual_stdout, actual_stderr = capture_output do
Faker::Deprecator.skip_warning do
Faker::Dogs.say
end
end
assert_empty(actual_stdout)
assert_empty(actual_stderr)
assert_equal 'meow', Faker::Dogs.say
end
def test_deprecated_with_skip_warning_does_not_generate_message
Faker::Deprecator.skip_warning do
assert_not_deprecated do
Faker::Dogs.say
end
end
assert_equal 'meow', Faker::Dogs.say
end
end
module Faker
class Cats < Base
def self.say
'meow'
end
end
include Faker::Deprecator
deprecate_generator('Dogs', Cats)
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/blockchain/test_aeternity.rb | test/faker/blockchain/test_aeternity.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerAeternity < Test::Unit::TestCase
def setup
@tester = Faker::Blockchain::Aeternity
end
def test_address
assert_match(/ak_([0-9a-zA-Z]{50}$)/, @tester.address)
end
def test_transaction
assert_match(/th_([0-9a-zA-Z]{51}$)/, @tester.transaction)
end
def test_contract
assert_match(/ct_([0-9a-zA-Z]{50}$)/, @tester.contract)
end
def test_oracle
assert_match(/ok_([0-9a-zA-Z]{51}$)/, @tester.oracle)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/blockchain/test_bitcoin.rb | test/faker/blockchain/test_bitcoin.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerBitcoin < Test::Unit::TestCase
def test_address
assert_match(/^[13][1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Bitcoin.address)
end
def test_deterministic_address
Faker::Config.random = Random.new(42)
v = Faker::Blockchain::Bitcoin.address
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Blockchain::Bitcoin.address
end
def test_testnet_address
assert_match(/\A[mn][1-9A-Za-z]{32,34}\Z/, Faker::Blockchain::Bitcoin.testnet_address)
assert_not_match(/[OIl]/, Faker::Blockchain::Bitcoin.testnet_address)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/blockchain/test_ethereum.rb | test/faker/blockchain/test_ethereum.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerEthereum < Test::Unit::TestCase
def setup
@tester = Faker::Blockchain::Ethereum
end
def test_address
assert_match(/0x([a-fA-F0-9]{40})/, @tester.address)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/blockchain/test_tezos.rb | test/faker/blockchain/test_tezos.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerTezos < Test::Unit::TestCase
def test_contract
assert_match(/^KT1[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.contract)
end
def test_account
assert_match(/^tz1[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.account)
end
def test_operation
assert_match(/^o[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.operation)
end
def test_block
assert_match(/^B[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.block)
end
def test_signature
assert_match(/^edsig[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.signature)
end
def test_public_key
assert_match(/^edpk[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.public_key)
end
def test_secret_key
assert_match(/^edsk[1-9A-Za-z][^OIl]{20,40}/, Faker::Blockchain::Tezos.secret_key)
end
def test_deterministic_contract
Faker::Config.random = Random.new(42)
v = Faker::Blockchain::Tezos.contract
Faker::Config.random = Random.new(42)
assert_equal v, Faker::Blockchain::Tezos.contract
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_smashing_pumpkins.rb | test/faker/music/test_faker_smashing_pumpkins.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerSmashingPumpkins < Test::Unit::TestCase
def setup
@tester = Faker::Music::SmashingPumpkins
end
def test_album
assert_match(/\w/, @tester.album)
end
def test_lyric
assert_match(/\w+/, @tester.lyric)
end
def test_musician
assert_match(/\w/, @tester.musician)
end
def test_song
assert_match(/\w/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_opera.rb | test/faker/music/test_faker_opera.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerOpera < Test::Unit::TestCase
def setup
@tester = Faker::Music::Opera
end
def verdi
assert_match(/\w+/i, @tester.verdi)
end
def rossini
assert_match(/\w+/i, @tester.rossini)
end
def donizetti
assert_match(/\w+/i, @tester.donizetti)
end
def bellini
assert_match(/\w+/i, @tester.bellini)
end
def mozart
assert_match(/\w+/i, @tester.mozart)
end
def mozart_italian
assert_match(/\w+/i, @tester.mozart_italian)
end
def mozart_german
assert_match(/\w+/i, @tester.mozart_german)
end
def gluck
assert_match(/\w+/i, @tester.gluck)
end
def gluck_italian
assert_match(/\w+/i, @tester.gluck_italian)
end
def gluck_french
assert_match(/\w+/i, @tester.gluck_french)
end
def beethoven
assert_match(/\w+/i, @tester.beethoven)
end
def weber
assert_match(/\w+/i, @tester.weber)
end
def strauss
assert_match(/\w+/i, @tester.strauss)
end
def wagner
assert_match(/\w+/i, @tester.wagner)
end
def schumann
assert_match(/\w+/i, @tester.schumann)
end
def schubert
assert_match(/\w+/i, @tester.schubert)
end
def berg
assert_match(/\w+/i, @tester.berg)
end
def ravel
assert_match(/\w+/i, @tester.ravel)
end
def berlioz
assert_match(/\w+/i, @tester.berlioz)
end
def bizet
assert_match(/\w+/i, @tester.bizet)
end
def gounod
assert_match(/\w+/i, @tester.gounod)
end
def saint_saens
assert_match(/\w+/i, @tester.saint_saens)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_umphreys_mcgee.rb | test/faker/music/test_faker_umphreys_mcgee.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerUmphreysMcgee < Test::Unit::TestCase
def setup
@tester = Faker::Music::UmphreysMcgee
end
def test_song
assert_match(/\w+/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_prince.rb | test/faker/music/test_faker_prince.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerPRince < Test::Unit::TestCase
def setup
@tester = Faker::Music::Prince
end
def test_song
assert_match(/\w+/, @tester.song)
end
def test_lyric
assert_match(/\w+/, @tester.lyric)
end
def test_album
assert_match(/\w+/, @tester.album)
end
def test_band
assert_match(/\w+/, @tester.band)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_rock_band.rb | test/faker/music/test_faker_rock_band.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerRockBand < Test::Unit::TestCase
def setup
@tester = Faker::Music::RockBand
end
def test_name
assert_match(/\w+/, @tester.name)
end
def test_song
assert_match(/\w+/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_hiphop.rb | test/faker/music/test_faker_hiphop.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerHiphop < Test::Unit::TestCase
def setup
@tester = Faker::Music::Hiphop
end
def test_artist
assert_match(/\w+/, @tester.artist)
end
def test_groups
assert_match(/\w+/, @tester.groups)
end
def test_subgenres
assert_match(/\w+/, @tester.subgenres)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_rush.rb | test/faker/music/test_faker_rush.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerRush < Test::Unit::TestCase
def setup
@tester = Faker::Music::Rush
end
def test_player
assert_match(/\w+/, @tester.player)
end
def test_album
assert_match(/\w+/, @tester.album)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_grateful_dead.rb | test/faker/music/test_faker_grateful_dead.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerGratefulDead < Test::Unit::TestCase
def setup
@tester = Faker::Music::GratefulDead
end
def test_player
assert_match(/\w/, @tester.player)
end
def test_song
assert_match(/\w/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_music.rb | test/faker/music/test_faker_music.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerMusic < Test::Unit::TestCase
def setup
@tester = Faker::Music
end
def test_keys
# rubocop:disable Style/HashEachMethods
assert_equal(7, @tester.keys.size)
@tester.keys.each do |key|
refute_empty key.to_s
end
# rubocop:enable Style/HashEachMethods
end
def test_key_variants
assert_equal(3, @tester.key_variants.size)
@tester.key_variants.each do |key_variant|
refute_nil key_variant
end
end
def test_key_types
assert_equal(2, @tester.key_types.size)
@tester.key_types.each do |key_type|
refute_nil key_type
end
end
def test_chord_types
assert_equal(12, @tester.chord_types.size)
@tester.chord_types.each do |chord_type|
refute_nil chord_type
end
end
def test_key
assert_match(/([A-Z])\s*(b|#){0,1}\s*(m){0,1}/, @tester.name)
end
def test_instrument
assert_match(/\w+/, @tester.instrument)
end
def test_chord
assert_match(/([A-Z])\s*(b|#){0,1}\s*([a-zA-Z0-9]{0,4})/, @tester.name)
end
def test_band
assert_match(/\w+/, @tester.band)
end
def test_album
assert_match(/\w+/, @tester.album)
end
def test_genre
assert_match(/\w+/, @tester.genre)
end
def test_mambo_no_5
assert_match(/\w+/, @tester.mambo_no_5)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_bossa_nova.rb | test/faker/music/test_faker_bossa_nova.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerBossaNova < Test::Unit::TestCase
def setup
@tester = Faker::Music::BossaNova
end
def test_artists
assert_match(/\w+/, @tester.artist)
end
def test_songs
assert_match(/\w+/, @tester.song)
end
def test_deprecation
assert_deprecated do
Faker::BossaNova.artist
end
assert_deprecated do
Faker::BossaNova.song
end
assert_match(/\w+/, Faker::BossaNova.artist)
assert_match(/\w+/, Faker::BossaNova.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_pearl_jam.rb | test/faker/music/test_faker_pearl_jam.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerPearlJam < Test::Unit::TestCase
def setup
@tester = Faker::Music::PearlJam
end
def test_musician
assert_match(/\w/, @tester.musician)
end
def test_album
assert_match(/\w/, @tester.album)
end
def test_song
assert_match(/\w/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/music/test_faker_phish.rb | test/faker/music/test_faker_phish.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerPhish < Test::Unit::TestCase
def setup
@tester = Faker::Music::Phish
end
def test_album
assert_match(/\w+/, @tester.album)
end
def test_musician
assert_match(/\w+/, @tester.musician)
end
def test_song
assert_match(/\w+/, @tester.song)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_job.rb | test/faker/default/test_faker_job.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerJob < Test::Unit::TestCase
def setup
@tester = Faker::Job
end
def test_title
assert_match(/(\w+\.? ?){2,3}/, @tester.title)
end
def test_field
assert_match(/(\w+\.? ?)/, @tester.field)
end
def test_key_skill
assert_match(/(\w+\.? ?)/, @tester.key_skill)
end
def test_position
assert_match(/(\w+\.? ?)/, @tester.position)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_emotion.rb | test/faker/default/test_faker_emotion.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerEmotion < Test::Unit::TestCase
def setup
@tester = Faker::Emotion
end
def test_noun
assert_match(/\w+/, @tester.noun)
end
def test_adjective
assert_match(/\w+/, @tester.adjective)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_city.rb | test/faker/default/test_faker_city.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerCity < Test::Unit::TestCase
def setup
@old_locales = I18n.config.available_locales
xx = {
faker: {
name: { female_first_name: ['alice'], male_first_name: ['alice'], last_name: ['smith'] },
address: { city_prefix: ['west'], city_suffix: ['burg'] }
}
}
I18n.config.available_locales += [:xx]
I18n.backend.store_translations(:xx, xx)
# rubocop:disable Lint/InterpolationCheck
xy = {
faker: {
address: {
city_prefix: ['big'],
city_root: ['rock'],
city_root_suffix: ['ing'],
city_suffix: ['town'],
city: ['#{city_prefix} #{city_root}#{city_root_suffix} #{city_suffix}']
}
}
}
# rubocop:enable Lint/InterpolationCheck
I18n.config.available_locales += [:xy]
I18n.backend.store_translations(:xy, xy)
end
def teardown
I18n.config.available_locales = @old_locales
end
def test_default_city_formats
I18n.with_locale(:xx) do
cities = ['west alice', 'west smith', 'west aliceburg', 'west smithburg', 'aliceburg', 'smithburg']
deterministically_verify -> { Faker::Address.city }, depth: 5 do |city|
assert_includes cities, city, "Expected <#{cities.join(' / ')}>, but got #{city}"
end
end
end
def test_city_formats_are_flexible
I18n.with_locale(:xy) do
cities = ['big rocking town']
city = Faker::Address.city
assert_includes cities, city, "Expected <#{cities.join(' / ')}>, but got #{city}"
end
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_finance.rb | test/faker/default/test_faker_finance.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerFinance < Test::Unit::TestCase
def setup
Faker::Config.locale = nil
end
def test_vat_number
assert_match(/\w+/, Faker::Finance.vat_number)
end
def test_vat_number_with_invalid_params
assert_raise ArgumentError do
Faker::Finance.vat_number(country: Faker::Lorem.word)
end
end
def test_vat_number_with_valid_params
Faker::Finance.vat_number_keys.each do |country|
assert_match(/\w+/, Faker::Finance.vat_number(country: country))
end
end
def test_south_african_vat_number
assert_match(/\AZA\d{10,11}\z/, Faker::Finance.vat_number(country: 'ZA'))
end
def test_ticker
assert_match(/\w+/, Faker::Finance.ticker)
end
def test_ticker_with_invalid_params
assert_raise ArgumentError do
Faker::Finance.ticker(Faker::Lorem.word)
end
end
def test_ticker_with_valid_params
ticker_return = Faker::Finance.ticker('nyse')
assert_includes Faker::Base.fetch_all('finance.ticker.nyse').join(', '), ticker_return
end
def test_stock_market
assert_match(/\w+/, Faker::Finance.stock_market)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_computer.rb | test/faker/default/test_faker_computer.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerComputer < Test::Unit::TestCase
def setup
@tester = Faker::Computer
@platforms = Faker::Base.fetch_all('computer.platform')
end
def test_type
assert_match(/\w+/, @tester.type)
end
def test_platform
assert_match(/(\w+ ?\d?){1,3}/, @tester.platform)
end
def test_stack
assert stack = @tester.stack
.match(/\A(?<platform>(?:[[:alnum:]]+\s?){1,5}), (?<os>(?:[[:alnum:]]+-?.?\)?\(?\s?){1,5})\z/)
platform = stack[:platform]
search_format_platform = platform.downcase
os = stack[:os]
oses = Faker::Base.fetch_all("computer.os.#{search_format_platform}")
assert_includes @platforms, platform
assert_includes oses, os
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_electrical_components.rb | test/faker/default/test_faker_electrical_components.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerElectricalComponents < Test::Unit::TestCase
def setup
@tester = Faker::ElectricalComponents
end
def test_active
assert_match(/\w+/, @tester.active)
end
def test_passive
assert_match(/\w+/, @tester.passive)
end
def test_electromechanical
assert_match(/\w+/, @tester.electromechanical)
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
faker-ruby/faker | https://github.com/faker-ruby/faker/blob/a4d5e503edda970fc085e942018ee235622bfb11/test/faker/default/test_faker_code.rb | test/faker/default/test_faker_code.rb | # frozen_string_literal: true
require_relative '../../test_helper'
class TestFakerCode < Test::Unit::TestCase
def setup
@tester = Faker::Code
end
def test_npi_regexp
assert_match(/[0-9]{10}/, @tester.npi)
end
def test_deterministic_npi
Faker::Config.random = Random.new(42)
v = @tester.npi
Faker::Config.random = Random.new(42)
assert_equal v, @tester.npi
end
def test_default_isbn_regexp
assert_match(/^\d{9}-[\d|X]$/, @tester.isbn)
end
def test_default_isbn13_regexp
assert_match(/^\d{12}-\d$/, @tester.isbn(base: 13))
end
def test_default_ean_regexp
assert_match(/^\d{13}$/, @tester.ean)
end
def test_default_ean8_regexp
assert_match(/^\d{8}$/, @tester.ean(base: 8))
end
def test_rut
assert_match(/^\d{1,8}-(\d|k)$/, @tester.rut)
end
def test_asin
assert_match(/^B000([A-Z]|\d){6}$/, @tester.asin)
end
def test_nric
assert_match(/^(S|T)\d{7}[A-JZ]$/, @tester.nric)
end
def test_imei_regexp
assert_match(/\A[\d.:\-\s]+\z/i, @tester.imei)
end
def test_imei_luhn_value
assert luhn_checksum_valid?(@tester.imei)
end
def test_sin
assert_match(/\d{9}/, @tester.sin)
assert_equal(9, @tester.sin.length)
assert luhn_checksum_valid?(@tester.sin)
end
def luhn_checksum_valid?(numbers)
sum = 0
i = 0
numbers.each_char do |ch|
n = ch.to_i
n *= 2 if i.odd?
n = 1 + (n - 10) if n >= 10
sum += n
i += 1
end
(sum % 10).zero?
end
end
| ruby | MIT | a4d5e503edda970fc085e942018ee235622bfb11 | 2026-01-04T15:37:50.353881Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.