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 setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { $arg }
""")))
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("""
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
}
""")))
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
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 }
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("""
-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_has_message_for_term(self):
self.bundle.add_resource(
FluentResource(dedent_ftl("""
-foo = Foo
""")))
self.assertFalse(self.bundle.has_message('-foo'))
def test_format_term(self):
self.bundle.add_resource(
FluentResource(dedent_ftl("""
-foo = Foo
""")))
self.assertRaises(LookupError, self.bundle.get_message, '-foo')
self.assertRaises(LookupError, self.bundle.get_message, 'foo')
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 test_format_args(self):
self.bundle.add_resource(FluentResource('foo = Foo'))
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').value)
self.assertEqual(val, 'Foo')
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').value, {})
self.assertEqual(val, 'Foo')
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
missing = { MISSING(1) }
""")))
def test_has_message(self):
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo
""")))
self.assertTrue(self.bundle.has_message('foo'))
self.assertFalse(self.bundle.has_message('bar'))
def resources(locale, resource_ids):
for root in settings.FLUENT_PATHS:
resources = []
for resource_id in resource_ids:
path = root.joinpath(locale, resource_id)
if not path.is_file():
continue
with path.open(encoding='utf-8') as ftl_file:
resources.append(FluentResource(ftl_file.read()))
if resources:
if locale != 'en':
path = settings.FLUENT_LOCAL_PATH.joinpath('en', 'brands.ftl')
with path.open(encoding='utf-8') as ftl_file:
resources.append(FluentResource(ftl_file.read()))
yield resources
def test_message_and_term_separate(self):
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Refers to { -foo }
-foo = Foo
""")))
val, errs = self.bundle.format_pattern(self.bundle.get_message('foo').value, {})
self.assertEqual(val, 'Refers to \u2068Foo\u2069')
self.assertEqual(errs, [])
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.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("""
msg = Msg is {$arg}
-foo = {msg}
ref-foo = {-foo(arg: 1)}
""")))
def test_has_message_with_attribute(self):
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo
.attr = Foo Attribute
""")))
self.assertTrue(self.bundle.has_message('foo'))
self.assertFalse(self.bundle.has_message('foo.attr'))
self.assertFalse(self.bundle.has_message('foo.other-attribute'))
def test_add_resource(self):
self.bundle.add_resource(FluentResource(dedent_ftl("""
foo = Foo
bar = Bar
-baz = Baz
""")))
self.assertIn('foo', self.bundle._messages)
self.assertIn('bar', self.bundle._messages)
self.assertIn('baz', self.bundle._terms)
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'])
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("""
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)}
""")))
def test_with_argument_expression(self):
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { $arg ->
[a] A
*[b] B
}
""")))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value, {'arg': 'a'})
self.assertEqual(val, "A")
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
implicit-call = { 123456 }
implicit-call2 = { $arg }
defaults = { NUMBER(123456) }
percent-style = { NUMBER(1.234, style: "percent") }
currency-style = { NUMBER(123456, style: "currency", currency: "USD") }
from-arg = { NUMBER($arg) }
merge-params = { NUMBER($arg, useGrouping: 0) }
""")))
def test_with_a_non_matching_selector(self):
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { "c" ->
[a] A
*[b] B
}
""")))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value, {})
self.assertEqual(val, "B")
self.assertEqual(len(errs), 0)
def test_with_a_missing_selector(self):
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
foo = { $none ->
[a] A
*[b] B
}
""")))
val, errs = self.bundle.format_pattern(
self.bundle.get_message('foo').value, {})
self.assertEqual(val, "B")
self.assertEqual(errs,
[FluentReferenceError("Unknown external: none")])
def setUp(self):
self.bundle = FluentBundle(['en-US'], use_isolating=False)
self.bundle.add_resource(
FluentResource(
dedent_ftl("""
-thing = { $article ->
*[definite] the thing
[indefinite] a thing
[none] thing
}
thing-no-arg = { -thing }
thing-no-arg-alt = { -thing() }
thing-with-arg = { -thing(article: "indefinite") }
thing-positional-arg = { -thing("foo") }
thing-fallback = { -thing(article: "somethingelse") }
bad-term = { -missing() }
""")))
