def test_gen_locale_gentoo_no_charmap(self):
"""
Tests the return of successful gen_locale on Gentoo system without a charmap
"""
def file_search(search, pattern):
"""
mock file.search
"""
if len(pattern.split()) == 1:
return False
else: # charmap was supplied
return True
ret = {"stdout": "saltines", "stderr": "biscuits", "retcode": 0, "pid": 1337}
with patch.dict(localemod.__grains__, {"os_family": "Gentoo"}):
with patch.dict(
localemod.__salt__,
{
"file.search": file_search,
"file.replace": MagicMock(return_value=True),
"cmd.run_all": MagicMock(return_value=ret),
},
):
self.assertTrue(localemod.gen_locale("en_US.UTF-8"))
def test_gen_locale_verbose(self):
"""
Tests the return of successful gen_locale
"""
ret = {"stdout": "saltines", "stderr": "biscuits", "retcode": 0, "pid": 1337}
with patch.dict(localemod.__salt__, {"cmd.run_all": MagicMock(return_value=ret), "file.replace": MagicMock()}):
self.assertEqual(localemod.gen_locale("en_US.UTF-8", verbose=True), ret)
def test_gen_locale_not_valid(self):
"""
Tests the return of gen_locale when the provided locale is not found
"""
with patch.dict(localemod.__grains__, {"os": "Debian"}):
with patch.dict(localemod.__salt__, {"file.search": MagicMock(return_value=False)}):
self.assertFalse(localemod.gen_locale("foo"))
def test_gen_locale_not_valid(self):
'''
Tests the return of gen_locale when the provided locale is not found
'''
with patch.dict(localemod.__grains__, {'os': 'Debian'}):
with patch.dict(localemod.__salt__,
{'file.search': MagicMock(return_value=False)}):
self.assertFalse(localemod.gen_locale('foo'))
def test_gen_locale_verbose(self):
'''
Tests the return of successful gen_locale
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__salt__,
{'cmd.run_all': MagicMock(return_value=ret),
'file.replace': MagicMock()}):
self.assertEqual(localemod.gen_locale('en_US.UTF-8', verbose=True), ret)
def test_gen_locale_gentoo(self):
'''
Tests the return of successful gen_locale on Gentoo system
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}):
with patch.dict(localemod.__salt__,
{'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8 UTF-8'))
def test_gen_locale_debian_no_charmap(self):
'''
Tests the return of successful gen_locale on Debian system without a charmap
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__grains__, {'os': 'Debian'}), \
patch('salt.utils.path.which', MagicMock(return_value='/some/dir/path')), \
patch.dict(localemod.__salt__,
{'file.search': lambda s, p, flags: not len(p.split()) == 1,
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
assert localemod.gen_locale('en_US.UTF-8')
def test_gen_locale_ubuntu(self):
'''
Test the return of successful gen_locale on Ubuntu system
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__salt__,
{'file.replace': MagicMock(return_value=True),
'file.touch': MagicMock(return_value=None),
'file.append': MagicMock(return_value=None),
'cmd.run_all': MagicMock(return_value=ret)}):
with patch.dict(localemod.__grains__, {'os': 'Ubuntu'}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8'))
def test_gen_locale_suse_invalid(self):
'''
Tests the location where gen_locale is searching for generated paths.
:return:
'''
assert not localemod.gen_locale('de_DE.utf8')
assert localemod.log.error.called
msg = localemod.log.error.call_args[0][0] % (
localemod.log.error.call_args[0][1],
localemod.log.error.call_args[0][2])
assert localemod.os.listdir.call_args[0][0] == '/usr/share/locale'
assert msg == 'The provided locale "en_GB.utf8" is not found in /usr/share/locale'
def test_gen_locale_ubuntu(self):
'''
Test the return of successful gen_locale on Ubuntu system
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__salt__,
{'file.replace': MagicMock(return_value=True),
'file.touch': MagicMock(return_value=None),
'file.append': MagicMock(return_value=None),
'cmd.run_all': MagicMock(return_value=ret)}):
with patch.dict(localemod.__grains__, {'os': 'Ubuntu'}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8'))
def test_gen_locale_ubuntu(self):
'''
Test the return of successful gen_locale on Ubuntu system
'''
with patch.dict(
localemod.__salt__, {
'file.replace': MagicMock(return_value=True),
'file.touch': MagicMock(return_value=None),
'file.append': MagicMock(return_value=None),
'cmd.retcode': MagicMock(return_value='A')
}):
with patch.dict(localemod.__grains__, {'os': 'Ubuntu'}):
self.assertEqual(localemod.gen_locale('en_US.UTF-8'), 'A')
def test_gen_locale_gentoo(self):
'''
Tests the return of successful gen_locale on Gentoo system
'''
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}):
with patch.dict(
localemod.__salt__, {
'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.retcode': MagicMock(return_value='A')
}):
self.assertEqual(localemod.gen_locale('en_US.UTF-8 UTF-8'),
'A')
def test_gen_locale_gentoo(self):
'''
Tests the return of successful gen_locale on Gentoo system
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}), \
patch('salt.utils.path.which', MagicMock(return_value='/some/dir/path')), \
patch('os.listdir', MagicMock(return_value=['en_US.UTF-8'])), \
patch.dict(localemod.__salt__,
{'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
assert localemod.gen_locale('en_US.UTF-8 UTF-8')
def test_gen_locale_not_valid(self):
"""
Tests the return of gen_locale when the provided locale is not found
"""
assert not localemod.gen_locale("foo")
assert localemod.log.error.called
msg = localemod.log.error.call_args[0][0] % (
localemod.log.error.call_args[0][1],
localemod.log.error.call_args[0][2],
)
assert (
msg ==
'The provided locale "foo" is not found in /usr/share/i18n/SUPPORTED'
)
def test_gen_locale_verbose(self):
'''
Tests the return of successful gen_locale
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': '31337',
'pid': '1337'
}
with patch.dict(localemod.__salt__,
{'cmd.run_all': MagicMock(return_value=ret)}):
self.assertEqual(localemod.gen_locale('en_US.UTF-8', verbose=True),
ret)
def test_gen_locale_ubuntu(self):
'''
Test the return of successful gen_locale on Ubuntu system
'''
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__salt__,
{'file.replace': MagicMock(return_value=True),
'file.touch': MagicMock(return_value=None),
'file.append': MagicMock(return_value=None),
'cmd.run_all': MagicMock(return_value=ret)}), \
patch('salt.utils.path.which', MagicMock(return_value='/some/dir/path')), \
patch('os.listdir', MagicMock(return_value=['en_US'])), \
patch.dict(localemod.__grains__, {'os': 'Ubuntu'}):
assert localemod.gen_locale('en_US.UTF-8')
def test_gen_locale_debian(self):
"""
Tests the return of successful gen_locale on Debian system
"""
ret = {"stdout": "saltines", "stderr": "biscuits", "retcode": 0, "pid": 1337}
with patch.dict(localemod.__grains__, {"os": "Debian"}):
with patch.dict(
localemod.__salt__,
{
"file.search": MagicMock(return_value=True),
"file.replace": MagicMock(return_value=True),
"cmd.run_all": MagicMock(return_value=ret),
},
):
self.assertTrue(localemod.gen_locale("en_US.UTF-8 UTF-8"))
def test_gen_locale_verbose(self):
'''
Tests the return of successful gen_locale
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': 0,
'pid': 1337
}
with patch.dict(localemod.__salt__,
{'cmd.run_all': MagicMock(return_value=ret),
'file.replace': MagicMock()}), \
patch('salt.utils.path.which', MagicMock(return_value='/some/dir/path')), \
patch('os.listdir', MagicMock(return_value=['en_US'])):
assert localemod.gen_locale('en_US.UTF-8', verbose=True) == ret
def test_gen_locale(self):
'''
Tests the return of successful gen_locale
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': 0,
'pid': 1337
}
with patch.dict(
localemod.__salt__, {
'cmd.run_all': MagicMock(return_value=ret),
'file.replace': MagicMock()
}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8'))
def test_gen_locale_debian(self):
'''
Tests the return of successful gen_locale on Debian system
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': 0,
'pid': 1337
}
with patch.dict(localemod.__grains__, {'os': 'Debian'}), \
patch('salt.utils.which', MagicMock(return_value='/some/dir/path')), \
patch.dict(localemod.__salt__,
{'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8 UTF-8'))
def test_gen_locale_gentoo(self):
'''
Tests the return of successful gen_locale on Gentoo system
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': 0,
'pid': 1337
}
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}):
with patch.dict(
localemod.__salt__, {
'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)
}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8 UTF-8'))
def test_gen_locale_debian(self):
'''
Tests the return of successful gen_locale on Debian system
'''
ret = {
'stdout': 'saltines',
'stderr': 'biscuits',
'retcode': '31337',
'pid': '1337'
}
with patch.dict(localemod.__grains__, {'os': 'Debian'}):
with patch.dict(
localemod.__salt__, {
'file.search': MagicMock(return_value=True),
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)
}):
self.assertEqual(localemod.gen_locale('en_US.UTF-8 UTF-8'),
ret['retcode'])
def test_gen_locale_verbose(self):
"""
Tests the return of successful gen_locale
"""
ret = {
"stdout": "saltines",
"stderr": "biscuits",
"retcode": 0,
"pid": 1337
}
with patch.dict(
localemod.__salt__,
{
"cmd.run_all": MagicMock(return_value=ret),
"file.replace": MagicMock()
},
), patch("salt.utils.path.which",
MagicMock(return_value="/some/dir/path")), patch(
"os.listdir", MagicMock(return_value=["en_US"])):
assert localemod.gen_locale("en_US.UTF-8", verbose=True) == ret
def test_gen_locale_gentoo_no_charmap(self):
'''
Tests the return of successful gen_locale on Gentoo system without a charmap
'''
def file_search(search, pattern, flags):
'''
mock file.search
'''
if len(pattern.split()) == 1:
return False
else: # charmap was supplied
return True
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}):
with patch.dict(localemod.__salt__,
{'file.search': file_search,
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8'))
def test_gen_locale_gentoo_no_charmap(self):
'''
Tests the return of successful gen_locale on Gentoo system without a charmap
'''
def file_search(search, pattern, flags):
'''
mock file.search
'''
if len(pattern.split()) == 1:
return False
else: # charmap was supplied
return True
ret = {'stdout': 'saltines', 'stderr': 'biscuits', 'retcode': 0, 'pid': 1337}
with patch.dict(localemod.__grains__, {'os_family': 'Gentoo'}):
with patch.dict(localemod.__salt__,
{'file.search': file_search,
'file.replace': MagicMock(return_value=True),
'cmd.run_all': MagicMock(return_value=ret)}):
self.assertTrue(localemod.gen_locale('en_US.UTF-8'))
def test_gen_locale_debian(self):
"""
Tests the return of successful gen_locale on Debian system
"""
ret = {
"stdout": "saltines",
"stderr": "biscuits",
"retcode": 0,
"pid": 1337
}
with patch.dict(localemod.__grains__, {"os": "Debian"}), patch(
"salt.utils.path.which",
MagicMock(return_value="/some/dir/path")), patch.dict(
localemod.__salt__,
{
"file.search": MagicMock(return_value=True),
"file.replace": MagicMock(return_value=True),
"cmd.run_all": MagicMock(return_value=ret),
},
):
assert localemod.gen_locale("en_US.UTF-8 UTF-8")
def test_gen_locale_ubuntu(self):
"""
Test the return of successful gen_locale on Ubuntu system
"""
ret = {
"stdout": "saltines",
"stderr": "biscuits",
"retcode": 0,
"pid": 1337
}
with patch.dict(
localemod.__salt__,
{
"file.replace": MagicMock(return_value=True),
"file.touch": MagicMock(return_value=None),
"file.append": MagicMock(return_value=None),
"cmd.run_all": MagicMock(return_value=ret),
},
), patch("salt.utils.path.which",
MagicMock(return_value="/some/dir/path")), patch(
"os.listdir",
MagicMock(return_value=["en_US"])), patch.dict(
localemod.__grains__, {"os": "Ubuntu"}):
assert localemod.gen_locale("en_US.UTF-8")
