def test(expected, test, description):
bag = ParameterBag({'foo': 'bar'});
try:
self.assertEqual(expected, bag.resolveString(test), description);
except ParameterNotFoundException as e:
self.fail('{0} - "{1}"'.format(description, expected));
def test(expected, test, description):
bag = ParameterBag({'foo': 'bar'})
try:
self.assertEqual(expected, bag.resolveString(test),
description)
except ParameterNotFoundException as e:
self.fail('{0} - "{1}"'.format(description, expected))
def testHas(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.has
"""
bag = ParameterBag({'foo': 'bar'});
self.assertTrue(bag.has('foo'), '->has() returns True if a parameter is defined');
self.assertTrue(bag.has('Foo'), '->has() converts the key to lowercase');
self.assertFalse(bag.has('bar'), '->has() returns False if a parameter is not defined');
def testConstructor(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.__construct
"""
parameters = {
'foo': 'foo',
'bar': 'bar',
};
bag = ParameterBag(parameters);
self.assertEqual(parameters, bag.all(), '__init__() takes an array of parameters as its first argument');
def testHas(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.has
"""
bag = ParameterBag({'foo': 'bar'})
self.assertTrue(bag.has('foo'),
'->has() returns True if a parameter is defined')
self.assertTrue(bag.has('Foo'),
'->has() converts the key to lowercase')
self.assertFalse(
bag.has('bar'),
'->has() returns False if a parameter is not defined')
def testClear(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.clear
"""
parameters = {
'foo': 'foo',
'bar': 'bar',
};
bag = ParameterBag(parameters);
bag.clear();
self.assertEqual({}, bag.all(), '->clear() removes all parameters');
def testClear(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.clear
"""
parameters = {
'foo': 'foo',
'bar': 'bar',
}
bag = ParameterBag(parameters)
bag.clear()
self.assertEqual({}, bag.all(), '->clear() removes all parameters')
def testEscapeValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.escapeValue
"""
bag = ParameterBag()
bag.add({
'foo':
bag.escapeValue(
{'bar': {
'ding': 'I\'m a bar %foo %bar',
'zero': None
}}),
'bar':
bag.escapeValue('I\'m a %foo%'),
})
self.assertEqual('I\'m a %%foo%%', bag.get('bar'),
'->escapeValue() escapes % by doubling it')
self.assertEqual(
{'bar': {
'ding': 'I\'m a bar %%foo %%bar',
'zero': None
}}, bag.get('foo'), '->escapeValue() escapes % by doubling it')
def testResolveUnescapesValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolve
"""
bag = ParameterBag({
'foo': {'bar': {'ding': 'I\'m a bar %%foo %%bar'}},
'bar': 'I\'m a %%foo%%',
});
bag.resolve();
self.assertEqual('I\'m a %foo%', bag.get('bar'), '->resolveValue() supports % escaping by doubling it');
self.assertEqual({'bar': {'ding': 'I\'m a bar %foo %bar'}}, bag.get('foo'), '->resolveValue() supports % escaping by doubling it');
def testConstructor(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.__construct
"""
parameters = {
'foo': 'foo',
'bar': 'bar',
}
bag = ParameterBag(parameters)
self.assertEqual(
parameters, bag.all(),
'__init__() takes an array of parameters as its first argument')
def testIsFrozen(self):
"""
@covers Symfony\Component\DependencyInjection\Container.isFrozen
"""
sc = Container(ParameterBag({'foo': 'bar'}))
self.assertFalse(
sc.isFrozen(),
'->isFrozen() returns False if the parameters are not frozen')
sc.compile()
self.assertTrue(
sc.isFrozen(),
'->isFrozen() returns True if the parameters are frozen')
def testRemove(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.remove
"""
bag = ParameterBag({
'foo': 'foo',
'bar': 'bar',
})
bag.remove('foo')
self.assertEqual({'bar': 'bar'}, bag.all(),
'->remove() removes a parameter')
bag.remove('BAR')
self.assertEqual(
{}, bag.all(),
'->remove() converts key to lowercase before removing')
def testConstructor(self):
"""
@covers Symfony\Component\DependencyInjection\Container.__construct
"""
sc = Container()
self.assertEqual(
sc, sc.get('service_container'),
'__init__() automatically registers itself as a service')
sc = Container(ParameterBag({'foo': 'bar'}))
self.assertEqual(
{'foo': 'bar'},
sc.getParameterBag().all(),
'__init__() takes an array of parameters as its first argument')
def testRemove(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.remove
"""
bag = ParameterBag({
'foo': 'foo',
'bar': 'bar',
});
bag.remove('foo');
self.assertEqual({'bar': 'bar'}, bag.all(), '->remove() removes a parameter');
bag.remove('BAR');
self.assertEqual({}, bag.all(), '->remove() converts key to lowercase before removing');
def testCompile(self):
"""
@covers Symfony\Component\DependencyInjection\Container.compile
"""
sc = Container(ParameterBag({'foo': 'bar'}))
sc.compile()
self.assertTrue(
isinstance(sc.getParameterBag(), FrozenParameterBag),
'->compile() changes the parameter bag to a FrozenParameterBag instance'
)
self.assertEqual(
{'foo': 'bar'},
sc.getParameterBag().all(),
'->compile() copies the current parameters to the new parameter bag'
)
def testEscapeValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.escapeValue
"""
bag = ParameterBag();
bag.add({
'foo': bag.escapeValue({'bar': {'ding': 'I\'m a bar %foo %bar', 'zero': None}}),
'bar': bag.escapeValue('I\'m a %foo%'),
});
self.assertEqual('I\'m a %%foo%%', bag.get('bar'), '->escapeValue() escapes % by doubling it');
self.assertEqual({'bar': {'ding': 'I\'m a bar %%foo %%bar', 'zero': None}}, bag.get('foo'), '->escapeValue() escapes % by doubling it');
def testResolveIndicatesWhyAParameterIsNeeded(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolve
"""
bag = ParameterBag({'foo': '%bar%'})
try:
bag.resolve()
except ParameterNotFoundException as e:
self.assertEqual(
'The parameter "foo" has a dependency on a non-existent parameter "bar".',
e.getMessage())
bag = ParameterBag({'foo': '%bar%'})
try:
bag.resolve()
except ParameterNotFoundException as e:
self.assertEqual(
'The parameter "foo" has a dependency on a non-existent parameter "bar".',
e.getMessage())
def testGetSetParameter(self):
"""
@covers Symfony\Component\DependencyInjection\Container.setParameter
@covers Symfony\Component\DependencyInjection\Container.getParameter
"""
sc = Container(ParameterBag({'foo': 'bar'}))
sc.setParameter('bar', 'foo')
self.assertEqual('foo', sc.getParameter('bar'),
'->setParameter() sets the value of a new parameter')
sc.setParameter('foo', 'baz')
self.assertEqual(
'baz', sc.getParameter('foo'),
'->setParameter() overrides previously set parameter')
sc.setParameter('Foo', 'baz1')
self.assertEqual('baz1', sc.getParameter('foo'),
'->setParameter() converts the key to lowercase')
self.assertEqual('baz1', sc.getParameter('FOO'),
'->getParameter() converts the key to lowercase')
try:
sc.getParameter('baba')
self.fail(
'->getParameter() thrown an InvalidArgumentException if the key does not exist'
)
except Exception as e:
self.assertTrue(
isinstance(e, InvalidArgumentException),
'->getParameter() thrown an InvalidArgumentException if the key does not exist'
)
self.assertEqual(
'You have requested a non-existent parameter "baba".',
e.getMessage(),
'->getParameter() thrown an InvalidArgumentException if the key does not exist'
)
def __init__(self, parameterBag=None):
"""Constructor.
@param: ParameterBagInterface parameterBag A ParameterBagInterface instance
@api
"""
self._services = dict()
self._scopes = dict()
self._scopeChildren = dict()
self._scopedServices = dict()
self._scopeStacks = dict()
self._parameterBag = None
self._loading = dict()
if parameterBag is None:
self._parameterBag = ParameterBag()
else:
assert isinstance(parameterBag, ParameterBagInterface)
self._parameterBag = parameterBag
self.set('service_container', self)
def testResolveIndicatesWhyAParameterIsNeeded(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolve
"""
bag = ParameterBag({'foo': '%bar%'});
try:
bag.resolve();
except ParameterNotFoundException as e:
self.assertEqual('The parameter "foo" has a dependency on a non-existent parameter "bar".', e.getMessage());
bag = ParameterBag({'foo': '%bar%'});
try:
bag.resolve();
except ParameterNotFoundException as e:
self.assertEqual('The parameter "foo" has a dependency on a non-existent parameter "bar".', e.getMessage());
def testResolveUnescapesValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolve
"""
bag = ParameterBag({
'foo': {
'bar': {
'ding': 'I\'m a bar %%foo %%bar'
}
},
'bar': 'I\'m a %%foo%%',
})
bag.resolve()
self.assertEqual(
'I\'m a %foo%', bag.get('bar'),
'->resolveValue() supports % escaping by doubling it')
self.assertEqual({'bar': {
'ding': 'I\'m a bar %foo %bar'
}}, bag.get('foo'),
'->resolveValue() supports % escaping by doubling it')
def testGetSet(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.get
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.set
"""
bag = ParameterBag({'foo': 'bar'});
bag.set('bar', 'foo');
self.assertEqual('foo', bag.get('bar'), '->set() sets the value of a new parameter');
bag.set('foo', 'baz');
self.assertEqual('baz', bag.get('foo'), '->set() overrides previously set parameter');
bag.set('Foo', 'baz1');
self.assertEqual('baz1', bag.get('foo'), '->set() converts the key to lowercase');
self.assertEqual('baz1', bag.get('FOO'), '->get() converts the key to lowercase');
try:
bag.get('baba');
self.fail('->get() raise an InvalidArgumentException if the key does not exist');
except Exception as e:
self.assertTrue(isinstance(e, InvalidArgumentException), '->get() raise an InvalidArgumentException if the key does not exist');
self.assertEqual('You have requested a non-existent parameter "baba".', e.getMessage(), '->get() raise an InvalidArgumentException if the key does not exist');
def _getContainerBuilder(self):
return ContainerBuilder(ParameterBag(self._getKernelParameters()))
def testResolveValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolveValue
"""
bag = ParameterBag({});
self.assertEqual('foo', bag.resolveValue('foo'), '->resolveValue() returns its argument unmodified if no placeholders are found');
bag = ParameterBag({'foo': 'bar'});
self.assertEqual('I\'m a bar', bag.resolveValue('I\'m a %foo%'), '->resolveValue() replaces placeholders by their values');
self.assertEqual({'bar': 'bar'}, bag.resolveValue({'%foo%': '%foo%'}), '->resolveValue() replaces placeholders in keys and values of arrays');
self.assertEqual({'bar': {'bar': {'bar': 'bar'}}}, bag.resolveValue({'%foo%': {'%foo%': {'%foo%': '%foo%'}}}), '->resolveValue() replaces placeholders in nested arrays');
self.assertEqual('I\'m a %%foo%%', bag.resolveValue('I\'m a %%foo%%'), '->resolveValue() supports % escaping by doubling it');
self.assertEqual('I\'m a bar %%foo bar', bag.resolveValue('I\'m a %foo% %%foo %foo%'), '->resolveValue() supports % escaping by doubling it');
self.assertEqual({'foo': {'bar': {'ding': 'I\'m a bar %%foo %%bar'}}}, bag.resolveValue({'foo': {'bar': {'ding': 'I\'m a bar %%foo %%bar'}}}), '->resolveValue() supports % escaping by doubling it');
bag = ParameterBag({'foo': True});
self.assertTrue(bag.resolveValue('%foo%'), '->resolveValue() replaces arguments that are just a placeholder by their value without casting them to strings');
bag = ParameterBag({'foo': None});
self.assertTrue(None is bag.resolveValue('%foo%'), '->resolveValue() replaces arguments that are just a placeholder by their value without casting them to strings');
bag = ParameterBag({'foo': 'bar', 'baz': '%%%foo% %foo%%% %%foo%% %%%foo%%%'});
self.assertEqual('%%bar bar%% %%foo%% %%bar%%', bag.resolveValue('%baz%'), '->resolveValue() replaces params placed besides escaped %');
bag = ParameterBag({'baz': '%%s?%%s'});
self.assertEqual('%%s?%%s', bag.resolveValue('%baz%'), '->resolveValue() is not replacing greedily');
bag = ParameterBag({});
try:
bag.resolveValue('%foobar%');
self.fail('->resolveValue() raise an InvalidArgumentException if a placeholder references a non-existent parameter');
except ParameterNotFoundException as e:
self.assertEqual('You have requested a non-existent parameter "foobar".', e.getMessage(), '->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter');
try:
bag.resolveValue('foo %foobar% bar');
self.fail('->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter');
except ParameterNotFoundException as e:
self.assertEqual('You have requested a non-existent parameter "foobar".', e.getMessage(), '->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter');
bag = ParameterBag({'foo': 'a %bar%', 'bar': {}});
try:
bag.resolveValue('%foo%');
self.fail('->resolveValue() raise a RuntimeException when a parameter embeds another non-string parameter');
except RuntimeException as e:
self.assertEqual('A string value must be composed of strings and/or numbers, but found parameter "bar" of type dict inside string value "a %bar%".', e.getMessage(), '->resolveValue() raise a RuntimeException when a parameter embeds another non-string parameter');
bag = ParameterBag({'foo': '%bar%', 'bar': '%foobar%', 'foobar': '%foo%'});
try:
bag.resolveValue('%foo%');
self.fail('->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference');
except ParameterCircularReferenceException as e:
self.assertEqual('Circular reference detected for parameter "foo" ("foo" > "bar" > "foobar" > "foo").', e.getMessage(), '->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference');
bag = ParameterBag({'foo': 'a %bar%', 'bar': 'a %foobar%', 'foobar': 'a %foo%'});
try:
bag.resolveValue('%foo%');
self.fail('->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference');
except ParameterCircularReferenceException as e:
self.assertEqual('Circular reference detected for parameter "foo" ("foo" > "bar" > "foobar" > "foo").', e.getMessage(), '->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference');
bag = ParameterBag({'host': 'foo.bar', 'port': 1337});
self.assertEqual('foo.bar:1337', bag.resolveValue('%host%:%port%'));
def testResolveValue(self):
"""
@covers Symfony\Component\DependencyInjection\ParameterBag\ParameterBag.resolveValue
"""
bag = ParameterBag({})
self.assertEqual(
'foo', bag.resolveValue('foo'),
'->resolveValue() returns its argument unmodified if no placeholders are found'
)
bag = ParameterBag({'foo': 'bar'})
self.assertEqual(
'I\'m a bar', bag.resolveValue('I\'m a %foo%'),
'->resolveValue() replaces placeholders by their values')
self.assertEqual({'bar': 'bar'}, bag.resolveValue(
{'%foo%': '%foo%'}
), '->resolveValue() replaces placeholders in keys and values of arrays'
)
self.assertEqual({'bar': {
'bar': {
'bar': 'bar'
}
}}, bag.resolveValue({'%foo%': {
'%foo%': {
'%foo%': '%foo%'
}
}}), '->resolveValue() replaces placeholders in nested arrays')
self.assertEqual(
'I\'m a %%foo%%', bag.resolveValue('I\'m a %%foo%%'),
'->resolveValue() supports % escaping by doubling it')
self.assertEqual(
'I\'m a bar %%foo bar',
bag.resolveValue('I\'m a %foo% %%foo %foo%'),
'->resolveValue() supports % escaping by doubling it')
self.assertEqual({'foo': {
'bar': {
'ding': 'I\'m a bar %%foo %%bar'
}
}},
bag.resolveValue({
'foo': {
'bar': {
'ding': 'I\'m a bar %%foo %%bar'
}
}
}),
'->resolveValue() supports % escaping by doubling it')
bag = ParameterBag({'foo': True})
self.assertTrue(
bag.resolveValue('%foo%'),
'->resolveValue() replaces arguments that are just a placeholder by their value without casting them to strings'
)
bag = ParameterBag({'foo': None})
self.assertTrue(
None is bag.resolveValue('%foo%'),
'->resolveValue() replaces arguments that are just a placeholder by their value without casting them to strings'
)
bag = ParameterBag({
'foo': 'bar',
'baz': '%%%foo% %foo%%% %%foo%% %%%foo%%%'
})
self.assertEqual(
'%%bar bar%% %%foo%% %%bar%%', bag.resolveValue('%baz%'),
'->resolveValue() replaces params placed besides escaped %')
bag = ParameterBag({'baz': '%%s?%%s'})
self.assertEqual('%%s?%%s', bag.resolveValue('%baz%'),
'->resolveValue() is not replacing greedily')
bag = ParameterBag({})
try:
bag.resolveValue('%foobar%')
self.fail(
'->resolveValue() raise an InvalidArgumentException if a placeholder references a non-existent parameter'
)
except ParameterNotFoundException as e:
self.assertEqual(
'You have requested a non-existent parameter "foobar".',
e.getMessage(),
'->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter'
)
try:
bag.resolveValue('foo %foobar% bar')
self.fail(
'->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter'
)
except ParameterNotFoundException as e:
self.assertEqual(
'You have requested a non-existent parameter "foobar".',
e.getMessage(),
'->resolveValue() raise a ParameterNotFoundException if a placeholder references a non-existent parameter'
)
bag = ParameterBag({
'foo': 'a %bar%',
'bar': {}
})
try:
bag.resolveValue('%foo%')
self.fail(
'->resolveValue() raise a RuntimeException when a parameter embeds another non-string parameter'
)
except RuntimeException as e:
self.assertEqual(
'A string value must be composed of strings and/or numbers, but found parameter "bar" of type dict inside string value "a %bar%".',
e.getMessage(),
'->resolveValue() raise a RuntimeException when a parameter embeds another non-string parameter'
)
bag = ParameterBag({
'foo': '%bar%',
'bar': '%foobar%',
'foobar': '%foo%'
})
try:
bag.resolveValue('%foo%')
self.fail(
'->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference'
)
except ParameterCircularReferenceException as e:
self.assertEqual(
'Circular reference detected for parameter "foo" ("foo" > "bar" > "foobar" > "foo").',
e.getMessage(),
'->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference'
)
bag = ParameterBag({
'foo': 'a %bar%',
'bar': 'a %foobar%',
'foobar': 'a %foo%'
})
try:
bag.resolveValue('%foo%')
self.fail(
'->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference'
)
except ParameterCircularReferenceException as e:
self.assertEqual(
'Circular reference detected for parameter "foo" ("foo" > "bar" > "foobar" > "foo").',
e.getMessage(),
'->resolveValue() raise a ParameterCircularReferenceException when a parameter has a circular reference'
)
bag = ParameterBag({
'host': 'foo.bar',
'port': 1337
})
self.assertEqual('foo.bar:1337', bag.resolveValue('%host%:%port%'))
