494 lines
16 KiB
Ruby
494 lines
16 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
require 'simple_po_parser'
|
|
|
|
# Disabling this cop to allow for multi-language examples in comments
|
|
# rubocop:disable Style/AsciiComments
|
|
RSpec.describe Gitlab::I18n::PoLinter do
|
|
let(:linter) { described_class.new(po_path: po_path, html_todolist: {}) }
|
|
let(:po_path) { 'spec/fixtures/valid.po' }
|
|
|
|
def fake_translation(msgid:, translation:, plural_id: nil, plurals: [])
|
|
data = { msgid: msgid, msgid_plural: plural_id }
|
|
|
|
if plural_id
|
|
[translation, *plurals].each_with_index do |plural, index|
|
|
allow(FastGettext::Translation).to receive(:n_).with(msgid, plural_id, index).and_return(plural)
|
|
data.merge!("msgstr[#{index}]" => plural)
|
|
end
|
|
else
|
|
allow(FastGettext::Translation).to receive(:_).with(msgid).and_return(translation)
|
|
data[:msgstr] = translation
|
|
end
|
|
|
|
Gitlab::I18n::TranslationEntry.new(
|
|
entry_data: data,
|
|
nplurals: plurals.size + 1,
|
|
html_allowed: nil
|
|
)
|
|
end
|
|
|
|
describe '#errors' do
|
|
it 'only calls validation once' do
|
|
expect(linter).to receive(:validate_po).once.and_call_original
|
|
|
|
2.times { linter.errors }
|
|
end
|
|
end
|
|
|
|
describe '#validate_po' do
|
|
subject(:errors) { linter.validate_po }
|
|
|
|
context 'for a fuzzy message' do
|
|
let(:po_path) { 'spec/fixtures/fuzzy.po' }
|
|
|
|
it 'has an error' do
|
|
is_expected.to include('PipelineSchedules|Remove variable row' => ['is marked fuzzy'])
|
|
end
|
|
end
|
|
|
|
context 'for a translations with newlines' do
|
|
let(:po_path) { 'spec/fixtures/newlines.po' }
|
|
|
|
it 'has an error for a normal string' do
|
|
message_id = "You are going to remove %{group_name}.\\nRemoved groups CANNOT be restored!\\nAre you ABSOLUTELY sure?"
|
|
expected_message = "is defined over multiple lines, this breaks some tooling."
|
|
|
|
expect(errors[message_id]).to include(expected_message)
|
|
end
|
|
|
|
it 'has an error when a translation is defined over multiple lines' do
|
|
message_id = "You are going to remove %{group_name}.\\nRemoved groups CANNOT be restored!\\nAre you ABSOLUTELY sure?"
|
|
expected_message = "has translations defined over multiple lines, this breaks some tooling."
|
|
|
|
expect(errors[message_id]).to include(expected_message)
|
|
end
|
|
|
|
it 'raises an error when a plural translation is defined over multiple lines' do
|
|
message_id = 'With plural'
|
|
expected_message = "has translations defined over multiple lines, this breaks some tooling."
|
|
|
|
expect(errors[message_id]).to include(expected_message)
|
|
end
|
|
|
|
it 'raises an error when the plural id is defined over multiple lines' do
|
|
message_id = 'multiline plural id'
|
|
expected_message = "plural is defined over multiple lines, this breaks some tooling."
|
|
|
|
expect(errors[message_id]).to include(expected_message)
|
|
end
|
|
end
|
|
|
|
context 'with an invalid po' do
|
|
let(:po_path) { 'spec/fixtures/invalid.po' }
|
|
|
|
it 'returns the error' do
|
|
is_expected.to include('PO-syntax errors' => a_kind_of(Array))
|
|
end
|
|
|
|
it 'does not validate entries' do
|
|
expect(linter).not_to receive(:validate_entries)
|
|
|
|
linter.validate_po
|
|
end
|
|
end
|
|
|
|
context 'with missing metadata' do
|
|
let(:po_path) { 'spec/fixtures/missing_metadata.po' }
|
|
|
|
it 'returns the an error' do
|
|
is_expected.to include('PO-syntax errors' => a_kind_of(Array))
|
|
end
|
|
end
|
|
|
|
context 'with a valid po' do
|
|
it 'parses the file' do
|
|
expect(linter).to receive(:parse_po).and_call_original
|
|
|
|
linter.validate_po
|
|
end
|
|
|
|
it 'validates the entries' do
|
|
expect(linter).to receive(:validate_entries).and_call_original
|
|
|
|
linter.validate_po
|
|
end
|
|
|
|
it 'has no errors' do
|
|
is_expected.to be_empty
|
|
end
|
|
end
|
|
|
|
context 'with missing plurals' do
|
|
let(:po_path) { 'spec/fixtures/missing_plurals.po' }
|
|
|
|
it 'has errors' do
|
|
is_expected.not_to be_empty
|
|
end
|
|
end
|
|
|
|
context 'with multiple plurals' do
|
|
let(:po_path) { 'spec/fixtures/multiple_plurals.po' }
|
|
|
|
it 'has errors' do
|
|
is_expected.not_to be_empty
|
|
end
|
|
end
|
|
|
|
context 'with unescaped chars' do
|
|
let(:po_path) { 'spec/fixtures/unescaped_chars.po' }
|
|
|
|
it 'contains an error' do
|
|
message_id = 'You are going to transfer %{project_name_with_namespace} to another namespace. Are you ABSOLUTELY sure?'
|
|
expected_error = 'translation contains unescaped `%`, escape it using `%%`'
|
|
|
|
expect(errors[message_id]).to include(expected_error)
|
|
end
|
|
end
|
|
|
|
context 'when an entry contains html' do
|
|
let(:po_path) { 'spec/fixtures/potential_html.po' }
|
|
|
|
it 'presents an error for each component containing angle brackets' do
|
|
message_id = 'String with some <strong>emphasis</strong>'
|
|
|
|
expect(errors[message_id]).to match_array [
|
|
a_string_starting_with('contains < or >.'),
|
|
a_string_starting_with('plural id contains < or >.'),
|
|
a_string_starting_with('translation contains < or >.')
|
|
]
|
|
end
|
|
end
|
|
|
|
context 'when an entry contains html on the todolist' do
|
|
subject(:linter) { described_class.new(po_path: po_path, html_todolist: todolist) }
|
|
|
|
let(:po_path) { 'spec/fixtures/potential_html.po' }
|
|
let(:todolist) do
|
|
{
|
|
'String with a legitimate < use' => {
|
|
'plural_id' => 'String with lots of < > uses',
|
|
'translations' => [
|
|
'Translated string with a legitimate < use',
|
|
'Translated string with lots of < > uses'
|
|
]
|
|
}
|
|
}
|
|
end
|
|
|
|
it 'does not present an error' do
|
|
message_id = 'String with a legitimate < use'
|
|
|
|
expect(errors[message_id]).to be_nil
|
|
end
|
|
end
|
|
|
|
context 'when an entry on the html todolist has changed' do
|
|
subject(:linter) { described_class.new(po_path: po_path, html_todolist: todolist) }
|
|
|
|
let(:po_path) { 'spec/fixtures/potential_html.po' }
|
|
let(:todolist) do
|
|
{
|
|
'String with a legitimate < use' => {
|
|
'plural_id' => 'String with lots of < > uses',
|
|
'translations' => [
|
|
'Translated string with a different legitimate < use',
|
|
'Translated string with lots of < > uses'
|
|
]
|
|
}
|
|
}
|
|
end
|
|
|
|
it 'presents an error for the changed component' do
|
|
message_id = 'String with a legitimate < use'
|
|
|
|
expect(errors[message_id])
|
|
.to include a_string_starting_with('translation contains < or >.')
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#parse_po' do
|
|
context 'with a valid po' do
|
|
it 'fills in the entries' do
|
|
linter.parse_po
|
|
|
|
expect(linter.translation_entries).not_to be_empty
|
|
expect(linter.metadata_entry).to be_kind_of(Gitlab::I18n::MetadataEntry)
|
|
end
|
|
|
|
it 'does not have errors' do
|
|
expect(linter.parse_po).to be_nil
|
|
end
|
|
end
|
|
|
|
context 'with an invalid po' do
|
|
let(:po_path) { 'spec/fixtures/invalid.po' }
|
|
|
|
it 'contains an error' do
|
|
expect(linter.parse_po).not_to be_nil
|
|
end
|
|
|
|
it 'sets the entries to an empty array' do
|
|
linter.parse_po
|
|
|
|
expect(linter.translation_entries).to eq([])
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#validate_entries' do
|
|
it 'keeps track of errors for entries' do
|
|
fake_invalid_entry = fake_translation(msgid: "Hello %{world}",
|
|
translation: "Bonjour %{monde}")
|
|
allow(linter).to receive(:translation_entries) { [fake_invalid_entry] }
|
|
|
|
expect(linter).to receive(:validate_entry)
|
|
.with(fake_invalid_entry)
|
|
.and_call_original
|
|
|
|
expect(linter.validate_entries).to include("Hello %{world}" => an_instance_of(Array))
|
|
end
|
|
end
|
|
|
|
describe '#validate_entry' do
|
|
it 'validates the flags, variable usage, newlines, and unescaped chars' do
|
|
fake_entry = double
|
|
|
|
expect(linter).to receive(:validate_flags).with([], fake_entry)
|
|
expect(linter).to receive(:validate_variables).with([], fake_entry)
|
|
expect(linter).to receive(:validate_newlines).with([], fake_entry)
|
|
expect(linter).to receive(:validate_number_of_plurals).with([], fake_entry)
|
|
expect(linter).to receive(:validate_unescaped_chars).with([], fake_entry)
|
|
expect(linter).to receive(:validate_translation).with([], fake_entry)
|
|
expect(linter).to receive(:validate_html).with([], fake_entry)
|
|
|
|
linter.validate_entry(fake_entry)
|
|
end
|
|
end
|
|
|
|
describe '#validate_number_of_plurals' do
|
|
it 'validates when there are an incorrect number of translations' do
|
|
fake_metadata = double
|
|
allow(fake_metadata).to receive(:expected_forms).and_return(2)
|
|
allow(linter).to receive(:metadata_entry).and_return(fake_metadata)
|
|
|
|
fake_entry = Gitlab::I18n::TranslationEntry.new(
|
|
entry_data: { msgid: 'the singular', msgid_plural: 'the plural', 'msgstr[0]' => 'the singular' },
|
|
nplurals: 2,
|
|
html_allowed: nil
|
|
)
|
|
errors = []
|
|
|
|
linter.validate_number_of_plurals(errors, fake_entry)
|
|
|
|
expect(errors).to include('should have 2 translations')
|
|
end
|
|
end
|
|
|
|
describe '#validate_variables' do
|
|
before do
|
|
allow(linter).to receive(:validate_variables_in_message).and_call_original
|
|
end
|
|
|
|
it 'validates both singular and plural in a pluralized string when the entry has a singular' do
|
|
pluralized_entry = fake_translation(
|
|
msgid: 'Hello %{world}',
|
|
translation: 'Bonjour %{world}',
|
|
plural_id: 'Hello all %{world}',
|
|
plurals: ['Bonjour tous %{world}']
|
|
)
|
|
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello %{world}', 'Bonjour %{world}')
|
|
.and_call_original
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello all %{world}', 'Bonjour tous %{world}')
|
|
.and_call_original
|
|
|
|
linter.validate_variables([], pluralized_entry)
|
|
end
|
|
|
|
it 'only validates plural when there is no separate singular' do
|
|
pluralized_entry = fake_translation(
|
|
msgid: 'Hello %{world}',
|
|
translation: 'Bonjour %{world}',
|
|
plural_id: 'Hello all %{world}'
|
|
)
|
|
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello all %{world}', 'Bonjour %{world}')
|
|
|
|
linter.validate_variables([], pluralized_entry)
|
|
end
|
|
|
|
it 'validates the message variables' do
|
|
entry = fake_translation(msgid: 'Hello', translation: 'Bonjour')
|
|
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello', 'Bonjour')
|
|
|
|
linter.validate_variables([], entry)
|
|
end
|
|
|
|
it 'validates variable usage in message ids' do
|
|
entry = fake_translation(
|
|
msgid: 'Hello %{world}',
|
|
translation: 'Bonjour %{world}',
|
|
plural_id: 'Hello all %{world}',
|
|
plurals: ['Bonjour tous %{world}']
|
|
)
|
|
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello %{world}', 'Hello %{world}')
|
|
.and_call_original
|
|
expect(linter).to receive(:validate_variables_in_message)
|
|
.with([], 'Hello all %{world}', 'Hello all %{world}')
|
|
.and_call_original
|
|
|
|
linter.validate_variables([], entry)
|
|
end
|
|
end
|
|
|
|
describe '#validate_variables_in_message' do
|
|
it 'detects when a variables are used incorrectly' do
|
|
errors = []
|
|
|
|
expected_errors = ['<%d hello %{world} %s> is missing: [%{hello}]',
|
|
'<%d hello %{world} %s> is using unknown variables: [%{world}]',
|
|
'is combining multiple unnamed variables',
|
|
'is combining named variables with unnamed variables']
|
|
|
|
linter.validate_variables_in_message(errors, '%d %{hello} world %s', '%d hello %{world} %s')
|
|
|
|
expect(errors).to include(*expected_errors)
|
|
end
|
|
|
|
it 'does not allow combining 1 `%d` unnamed variable with named variables' do
|
|
errors = []
|
|
|
|
linter.validate_variables_in_message(errors,
|
|
'%{type} detected %d vulnerability',
|
|
'%{type} detecteerde %d kwetsbaarheid')
|
|
|
|
expect(errors).not_to be_empty
|
|
end
|
|
end
|
|
|
|
describe '#validate_translation' do
|
|
let(:entry) { fake_translation(msgid: 'Hello %{world}', translation: 'Bonjour %{world}') }
|
|
|
|
it 'succeeds with valid variables' do
|
|
errors = []
|
|
|
|
linter.validate_translation(errors, entry)
|
|
|
|
expect(errors).to be_empty
|
|
end
|
|
|
|
it 'adds an error message when translating fails' do
|
|
errors = []
|
|
|
|
expect(FastGettext::Translation).to receive(:_) { raise 'broken' }
|
|
|
|
linter.validate_translation(errors, entry)
|
|
|
|
expect(errors).to include('Failure translating to en: broken')
|
|
end
|
|
|
|
it 'adds an error message when translating fails when translating with context' do
|
|
entry = fake_translation(msgid: 'Tests|Hello', translation: 'broken')
|
|
errors = []
|
|
|
|
expect(FastGettext::Translation).to receive(:s_) { raise 'broken' }
|
|
|
|
linter.validate_translation(errors, entry)
|
|
|
|
expect(errors).to include('Failure translating to en: broken')
|
|
end
|
|
|
|
it "adds an error when trying to translate with incorrect variables when using unnamed variables" do
|
|
entry = fake_translation(msgid: 'Hello %s', translation: 'Hello %d')
|
|
errors = []
|
|
|
|
linter.validate_translation(errors, entry)
|
|
|
|
expect(errors.first).to start_with("Failure translating to en")
|
|
end
|
|
|
|
it "adds an error when trying to translate with named variables when unnamed variables are expected" do
|
|
entry = fake_translation(msgid: 'Hello %s', translation: 'Hello %{thing}')
|
|
errors = []
|
|
|
|
linter.validate_translation(errors, entry)
|
|
|
|
expect(errors.first).to start_with("Failure translating to en")
|
|
end
|
|
|
|
it 'tests translation for all given forms' do
|
|
# Fake a language that has 3 forms to translate
|
|
fake_metadata = double
|
|
allow(fake_metadata).to receive(:forms_to_test).and_return(3)
|
|
allow(linter).to receive(:metadata_entry).and_return(fake_metadata)
|
|
entry = fake_translation(
|
|
msgid: '%d exception',
|
|
translation: '%d uitzondering',
|
|
plural_id: '%d exceptions',
|
|
plurals: ['%d uitzonderingen', '%d uitzonderingetjes']
|
|
)
|
|
|
|
# Make each count use a different index
|
|
allow(linter).to receive(:index_for_pluralization).with(0).and_return(0)
|
|
allow(linter).to receive(:index_for_pluralization).with(1).and_return(1)
|
|
allow(linter).to receive(:index_for_pluralization).with(2).and_return(2)
|
|
|
|
expect(FastGettext::Translation).to receive(:n_).with('%d exception', '%d exceptions', 0).and_call_original
|
|
expect(FastGettext::Translation).to receive(:n_).with('%d exception', '%d exceptions', 1).and_call_original
|
|
expect(FastGettext::Translation).to receive(:n_).with('%d exception', '%d exceptions', 2).and_call_original
|
|
|
|
linter.validate_translation([], entry)
|
|
end
|
|
end
|
|
|
|
describe '#numbers_covering_all_plurals' do
|
|
it 'can correctly find all required numbers to translate to Polish' do
|
|
# Polish used as an example with 3 different forms:
|
|
# 0, all plurals except the ones ending in 2,3,4: Kotów
|
|
# 1: Kot
|
|
# 2-3-4: Koty
|
|
# So translating with [0, 1, 2] will give us all different posibilities
|
|
fake_metadata = double
|
|
allow(fake_metadata).to receive(:forms_to_test).and_return(4)
|
|
allow(linter).to receive(:metadata_entry).and_return(fake_metadata)
|
|
allow(linter).to receive(:locale).and_return('pl_PL')
|
|
|
|
numbers = linter.numbers_covering_all_plurals
|
|
|
|
expect(numbers).to contain_exactly(0, 1, 2)
|
|
end
|
|
end
|
|
|
|
describe '#fill_in_variables' do
|
|
it 'builds an array for %d translations' do
|
|
result = linter.fill_in_variables(['%d'])
|
|
|
|
expect(result).to contain_exactly(a_kind_of(Integer))
|
|
end
|
|
|
|
it 'builds an array for %s translations' do
|
|
result = linter.fill_in_variables(['%s'])
|
|
|
|
expect(result).to contain_exactly(a_kind_of(String))
|
|
end
|
|
|
|
it 'builds a hash for named variables' do
|
|
result = linter.fill_in_variables(['%{hello}'])
|
|
|
|
expect(result).to be_a(Hash)
|
|
expect(result).to include('hello' => an_instance_of(String))
|
|
end
|
|
end
|
|
end
|
|
# rubocop:enable Style/AsciiComments
|