def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { $arg }
""")))
class TestBillionLaughs(unittest.TestCase):
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(
dedent_ftl("""
lol0 = 01234567890123456789012345678901234567890123456789
lol1 = {lol0}{lol0}{lol0}{lol0}{lol0}{lol0}{lol0}{lol0}{lol0}{lol0}
lol2 = {lol1}{lol1}{lol1}{lol1}{lol1}{lol1}{lol1}{lol1}{lol1}{lol1}
lol3 = {lol2}{lol2}{lol2}{lol2}{lol2}{lol2}{lol2}{lol2}{lol2}{lol2}
lol4 = {lol3}{lol3}{lol3}{lol3}{lol3}{lol3}{lol3}{lol3}{lol3}{lol3}
lolz = {lol4}
elol0 = { "" }
elol1 = {elol0}{elol0}{elol0}{elol0}{elol0}{elol0}{elol0}{elol0}{elol0}{elol0}
elol2 = {elol1}{elol1}{elol1}{elol1}{elol1}{elol1}{elol1}{elol1}{elol1}{elol1}
elol3 = {elol2}{elol2}{elol2}{elol2}{elol2}{elol2}{elol2}{elol2}{elol2}{elol2}
elol4 = {elol3}{elol3}{elol3}{elol3}{elol3}{elol3}{elol3}{elol3}{elol3}{elol3}
elol5 = {elol4}{elol4}{elol4}{elol4}{elol4}{elol4}{elol4}{elol4}{elol4}{elol4}
elol6 = {elol5}{elol5}{elol5}{elol5}{elol5}{elol5}{elol5}{elol5}{elol5}{elol5}
emptylolz = {elol6}
"""))
def test_max_length_protection(self):
val, errs = self.ctx.format('lolz')
self.assertEqual(val, ('0123456789' * 1000)[0:2500])
self.assertNotEqual(len(errs), 0)
def test_max_expansions_protection(self):
# Without protection, emptylolz will take a really long time to
# evaluate, although it generates an empty message.
val, errs = self.ctx.format('emptylolz')
self.assertEqual(val, '???')
self.assertEqual(len(errs), 1)
class TestAttributesWithStringValues(unittest.TestCase):
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo
.attr = Foo Attribute
bar = { foo } Bar
.attr = Bar Attribute
ref-foo = { foo.attr }
ref-bar = { bar.attr }
""")))
def test_can_be_referenced_for_entities_with_string_values(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('ref-foo').value, {})
self.assertEqual(val, 'Foo Attribute')
self.assertEqual(len(errs), 0)
def test_can_be_referenced_for_entities_with_pattern_values(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('ref-bar').value, {})
self.assertEqual(val, 'Bar Attribute')
self.assertEqual(len(errs), 0)
def test_can_be_formatted_directly_for_entities_with_string_values(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').attributes['attr'], {})
self.assertEqual(val, 'Foo Attribute')
self.assertEqual(len(errs), 0)
def test_can_be_formatted_directly_for_entities_with_pattern_values(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('bar').attributes['attr'], {})
self.assertEqual(val, 'Bar Attribute')
self.assertEqual(len(errs), 0)
def test_single_arg_missing_non_isolating(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource('foo = { $arg }'))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value)
self.assertEqual(val, 'arg')
self.assertEqual(len(errs), 1)
def test_plural_form_french(self):
# Just spot check one other, to ensure that we
# are not getting the EN locale by accident or
bundle = FluentBundle(['fr'])
self.assertEqual(bundle._plural_form(0), 'one')
self.assertEqual(bundle._plural_form(1), 'one')
self.assertEqual(bundle._plural_form(2), 'other')
class TestResolving(unittest.TestCase):
def setUp(self):
self.args_passed = []
def number_processor(number):
self.args_passed.append(number)
return number
self.ctx = FluentBundle(
['en-US'],
use_isolating=False,
functions={'NUMBER_PROCESSOR': number_processor})
self.ctx.add_messages(
dedent_ftl("""
pass-number = { NUMBER_PROCESSOR(1) }
pass-arg = { NUMBER_PROCESSOR($arg) }
"""))
def test_args_passed_as_numbers(self):
val, errs = self.ctx.format('pass-arg', {'arg': 1})
self.assertEqual(val, "1")
self.assertEqual(len(errs), 0)
self.assertEqual(self.args_passed, [1])
def test_literals_passed_as_numbers(self):
val, errs = self.ctx.format('pass-number', {})
self.assertEqual(val, "1")
self.assertEqual(len(errs), 0)
self.assertEqual(self.args_passed, [1])
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
-brand = Cool Thing
.status = { $version ->
[v2] available
*[v1] deprecated
}
attr-with-arg = { -brand } is { -brand.status(version: "v2") ->
[available] available, yay!
*[deprecated] deprecated, sorry
}
-other = { $arg ->
[a] ABC
*[d] DEF
}
missing-attr-ref = { -other.missing(arg: "a") ->
[ABC] ABC option
*[DEF] DEF option
}
""")))
def test_single_literal_number_non_isolating(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource('foo = { 1 }'))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value)
self.assertEqual(val, '1')
self.assertEqual(errs, [])
def test_single_arg_number_isolating(self):
self.bundle = FluentBundle(['en-US'], use_isolating=True)
self.bundle.add_resource(FluentResource('foo = { $arg }'))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value, {'arg': 1})
self.assertEqual(val, '1')
self.assertEqual(errs, [])
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
missing = { MISSING(1) }
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { 1 ->
*[0] A
[1] B
}
bar = { 2 ->
*[0] A
[1] B
}
baz = { $num ->
*[0] A
[1] B
}
qux = { 1.0 ->
*[0] A
[1] B
}
""")))
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(
dedent_ftl("""
message = Message
.attr = Message Attribute
-term = Term
.attr = Term Attribute
-term2 = {
*[variant1] Term Variant 1
[variant2] Term Variant 2
}
uses-message = { message }
uses-message-attr = { message.attr }
uses-term = { -term }
uses-term-variant = { -term2[variant2] }
bad-message-ref = Text { not-a-message }
bad-message-attr-ref = Text { message.not-an-attr }
bad-term-ref = Text { -not-a-term }
self-referencing-message = Text { self-referencing-message }
cyclic-msg1 = Text1 { cyclic-msg2 }
cyclic-msg2 = Text2 { cyclic-msg1 }
self-cyclic-message = Parent { self-cyclic-message.attr }
.attr = Attribute { self-cyclic-message }
self-attribute-ref-ok = Parent { self-attribute-ref-ok.attr }
.attr = Attribute
self-parent-ref-ok = Parent
.attr = Attribute { self-parent-ref-ok }
"""))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { 1 ->
[one] A
*[other] B
}
bar = { 1 ->
[1] A
*[other] B
}
baz = { "not a number" ->
[one] A
*[other] B
}
qux = { $num ->
[one] A
*[other] B
}
""")))
class TestNumbersInValues(unittest.TestCase):
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo { $num }
bar = { foo }
baz =
.attr = Baz Attribute { $num }
qux = { "a" ->
*[a] Baz Variant A { $num }
}
""")))
def test_can_be_used_in_the_message_value(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').value, {'num': 3})
self.assertEqual(val, 'Foo 3')
self.assertEqual(len(errs), 0)
def test_can_be_used_in_the_message_value_which_is_referenced(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('bar').value, {'num': 3})
self.assertEqual(val, 'Foo 3')
self.assertEqual(len(errs), 0)
def test_can_be_used_in_an_attribute(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('baz').attributes['attr'], {'num': 3})
self.assertEqual(val, 'Baz Attribute 3')
self.assertEqual(len(errs), 0)
def test_can_be_used_in_a_variant(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('qux').value, {'num': 3})
self.assertEqual(val, 'Baz Variant A 3')
self.assertEqual(len(errs), 0)
def setUp(self):
self.ctx = FluentBundle(['en-US'])
self.ctx.add_messages(dedent_ftl("""
-brand-short-name = Amaya
foo = { -brand-short-name }
with-arg = { $arg }
"""))
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(
dedent_ftl("""
implicit-call = { $date }
explicit-call = { DATETIME($date) }
call-with-arg = { DATETIME($date, dateStyle: "long") }
"""))
def setUp(self):
self.ctx = FluentBundle(['en-US'])
self.ctx.add_messages(dedent_ftl("""
foo = Foo
bar = { foo } Bar
baz = { $arg } Baz
qux = { bar } { baz }
"""))
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(
dedent_ftl("""
msg = Msg is {$arg}
-foo = {msg}
ref-foo = {-foo(arg: 1)}
"""))
def test_plural_form_english_ints(self):
bundle = FluentBundle(['en-US'])
self.assertEqual(bundle._plural_form(0),
'other')
self.assertEqual(bundle._plural_form(1),
'one')
self.assertEqual(bundle._plural_form(2),
'other')
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
msg = Msg is {$arg}
-foo = {msg}
ref-foo = {-foo(arg: 1)}
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'])
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
-brand-short-name = Amaya
foo = { -brand-short-name }
with-arg = { $arg }
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
implicit-call = { $date }
explicit-call = { DATETIME($date) }
call-with-arg = { DATETIME($date, dateStyle: "long") }
""")))
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(
dedent_ftl("""
-foo = {$a} {$b}
-bar = {-foo(b: 2)}
-baz = {-foo}
ref-bar = {-bar(a: 1)}
ref-baz = {-baz(a: 1)}
"""))
def setUp(self):
self.bundle = FluentBundle(['en-US'])
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = Foo
bar = { foo } Bar
baz = { $arg } Baz
qux = { bar } { baz }
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
one = { 1 }
one_point_two = { 1.2 }
select = { 1 ->
*[0] Zero
[1] One
}
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo
.attr = Foo Attribute
bar = { foo } Bar
.attr = Bar Attribute
ref-foo = { foo.attr }
ref-bar = { bar.attr }
""")))
def setUp(self):
self.ctx = FluentBundle(['en-US'], use_isolating=False)
self.ctx.add_messages(dedent_ftl("""
foo = Foo
.attr = Foo Attribute
bar = { foo } Bar
.attr = Bar Attribute
ref-foo = { foo.attr }
ref-bar = { bar.attr }
"""))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo { $num }
bar = { foo }
baz =
.attr = Baz Attribute { $num }
qux = { "a" ->
*[a] Baz Variant A { $num }
}
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
-foo = {$a} {$b}
-bar = {-foo(b: 2)}
-baz = {-foo}
ref-bar = {-bar(a: 1)}
ref-baz = {-baz(a: 1)}
""")))
class TestStrings(unittest.TestCase):
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = { $arg }
""")))
def test_can_be_a_string(self):
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').value, {'arg': 'Argument'})
self.assertEqual(val, 'Argument')
self.assertEqual(len(errs), 0)
