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)