def test_create_new_config_file(self):
lines = []
def _write(line):
lines.append(line)
write_fp = mock.Mock()
write_fp.write = mock.Mock(side_effect = _write)
c = burton.Config()
c._open_for_writing = mock.Mock(return_value = write_fp)
captured_log = testfixtures.LogCapture()
c.create_new_config_file("some_path")
captured_log.check(
(
burton.logger_name,
"ERROR",
"An empty config file has been created at some_path"
),
(
burton.logger_name,
"ERROR",
"Please fill out the config file and run your command again"
),
)
captured_log.uninstall()
self.assertEquals(
"".join(lines),
c._get_default_config_file().read()
)
def test_returns_false_if_missing_required_command_line_options(self):
c = burton.Config(
command_line_defaults = {
"foo" : None,
},
command_line_mapping = {
"--foo" : [ "foo", "str" ],
},
required_command_line_options = [ "foo" ],
)
captured_log = testfixtures.LogCapture()
self.assertFalse(c.parse_command_line_options("script_name", [ ]))
captured_log.check(
(burton.logger_name, "ERROR", "Missing required option foo"),
)
captured_log.uninstall()
captured_log = testfixtures.LogCapture()
self.assertFalse(c.parse_command_line_options(
"script_name",
[ "some_path", ]
))
captured_log.check(
(burton.logger_name, "ERROR", "Missing required option foo"),
)
captured_log.uninstall()
def test_parse_config_file_for_next_platform(self, mock_path_exists_func):
def _open_file(filename):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = 0
overidden_param = 0
[platform1]
default_param = 1
overidden_param = 1
[platform2]
overidden_param = 2
""".replace(" ", ""))
return config_fp
mock_path_exists_func.return_value = True
c = burton.Config({ "default_param" : None, "overidden_param" : None })
c._open_for_reading = mock.Mock(side_effect = _open_file)
c.parse_command_line_options("some_script", [])
self.assertEquals(c.num_remaining_platforms(), 2)
c.parse_config_file_for_next_platform()
self.assertEquals(c.get("default_param"), 1)
self.assertEquals(c.get("overidden_param"), 1)
c.parse_config_file_for_next_platform()
self.assertEquals(c.get("default_param"), 0)
self.assertEquals(c.get("overidden_param"), 2)
def test_calls_custom_methods_for_specified_keys(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = 0
overidden_param = 0
[platform1]
overidden_param = 1
""".replace(" ", ""))
target = mock.Mock()
target.custom_method = mock.Mock()
c = burton.Config(
config_file_defaults = {
"default_param" : None,
"overidden_param" : None
},
custom_methods = {
"default_param" : [ target, "custom_function" ]
},
)
self.assertTrue(c.readfp(config_fp, "platform1"))
target.custom_function.assert_called_with(0)
def test_strings_to_ignore(self, mock_path_exists_func, open_func):
config_dict = {
burton.Config.root_path : "root_path",
burton.Config.strings_to_ignore_file : "test_filename"
}
def _config_get(key):
return config_dict[key]
conf = burton.Config()
conf.get = mock.Mock(side_effect = _config_get)
mock_path_exists_func.return_value = True
open_func.return_value = cStringIO.StringIO("""ignore1
ignore2
ignore3""")
self.assertEquals(
conf.get_strings_to_ignore(),
[ "ignore1", "ignore2", "ignore3" ]
)
open_func.assert_called_with(
os.path.join("root_path", "test_filename"),
"r",
encoding = "utf8"
)
def test_parse_config_file_creates_new_file_when_necessary(
self,
mock_path_exists_func
):
c = burton.Config()
c.create_new_config_file = mock.Mock()
mock_path_exists_func.return_value = False
c.set(burton.Config.root_path, "some_path")
c.set(burton.Config.config_filename, "some_filename")
c.set(burton.Config.platform, "Mac")
self.assertFalse(c._parse_config_file())
c.create_new_config_file.assert_called_with(
os.path.join("some_path", "some_filename")
)
def test_parse_value(self):
c = burton.Config()
self.assertEquals(c._parse_value(None), None)
self.assertEquals(c._parse_value("None"), None)
self.assertEquals(c._parse_value("1"), 1)
self.assertEquals(c._parse_value('"String"'), "String")
self.assertEquals(c._parse_value("[1, 2, 3]"), [ 1, 2, 3])
test_passed = False
try:
c._parse_value("[invalid value")
except ValueError as e:
test_passed = True
finally:
self.assertTrue(test_passed)
def test_returns_false_if_encounters_unknown_command_line_options(self):
c = burton.Config(
command_line_defaults = { "platform" : None, },
command_line_mapping = { "--platform" : [ "platform", "str" ], },
required_command_line_options = [ "platform" ],
)
captured_log = testfixtures.LogCapture()
self.assertFalse(c.parse_command_line_options(
"script_name",
[ "some_path", "-o" ]
))
captured_log.check(
( burton.logger_name, "ERROR", "Unknown option -o" ),
)
captured_log.uninstall()
def test_parses_json_values(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = [ "1", 2, "three" ]
overidden_param = 0
[platform1]
overidden_param = { "1" : "one", "2" : "two" }
""".replace(" ", ""))
c = burton.Config({ "default_param" : None, "overidden_param" : None })
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(c.get("default_param"), [ "1", 2, "three" ])
self.assertEquals(
c.get("overidden_param"),
{ "1" : "one", "2" : "two" }
)
def test_returns_false_if_missing_required_variable(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
overidden_param = 0
[platform1]
overidden_param = 1
""".replace(" ", ""))
captured_log = testfixtures.LogCapture()
c = burton.Config({ "default_param" : None, "overidden_param" : None })
self.assertFalse(c.readfp(config_fp, "platform1"))
captured_log.check(
(burton.logger_name, "ERROR", "Unable to parse config file"),
(burton.logger_name, "ERROR", "default_param has not been set"),
)
captured_log.uninstall()
def test_creates_regexes_from_mapping_files(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
mapping_files = [ ]
[platform1]
mapping_files = [ "\\\\.strings$", "\\\\.rc$", "\\\\.resx$" ]
""".replace(" ", ""))
c = burton.Config({ burton.Config.mapping_files : [ ] })
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(
map(
lambda(regex): regex.pattern,
c.get(burton.Config.mapping_files)
),
[ "\\.strings$", "\\.rc$", "\\.resx$" ]
)
def test_overrides_default_values_with_platform_specific_values(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = 0
overidden_param = 0
[platform1]
overidden_param = 1
[platform2]
default_param = 2
overidden_param = 2
""".replace(" ", ""))
c = burton.Config({ "default_param" : None, "overidden_param" : None })
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(c.get("default_param"), 0)
self.assertEquals(c.get("overidden_param"), 1)
def test_creates_regexes_from_disallowed_paths(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
disallowed_paths = [ ]
[platform1]
disallowed_paths = [ "Shared Code/cpp_core/output", "build"]
""".replace(" ", ""))
c = burton.Config({ burton.Config.disallowed_paths : None })
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(
map(
lambda(regex): regex.pattern,
c.get(burton.Config.disallowed_paths)
),
[ "Shared Code/cpp_core/output", "build" ]
)
def test_creates_regexes_from_file_extensions(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
extensions_to_parse = [ ]
[platform1]
extensions_to_parse = [ "resx", "nib" ]
""".replace(" ", ""))
c = burton.Config({ burton.Config.extensions_to_parse : None })
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(
map(
lambda(regex): regex.pattern,
c.get(burton.Config.extensions_to_parse)
),
[ ".*\.resx$", ".*\.nib$" ]
)
def test_returns_false_if_config_file_does_not_contain_platform(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = 0
overidden_param = 0
[platform1]
overidden_param: 1
""".replace(" ", ""))
c = burton.Config({ "default_param" : None, "overidden_param" : None })
captured_log = testfixtures.LogCapture()
self.assertFalse(c.readfp(config_fp, "platform2"))
captured_log.check(
(burton.logger_name, "ERROR", "Unable to parse config file"),
(burton.logger_name, "ERROR", "Platform platform2 does not exist"),
)
captured_log.uninstall()
def test_parse_config_file(self, mock_path_exists_func):
config_fp = cStringIO.StringIO("""
[DEFAULT]
[platform1]
""".replace(" ", ""))
c = burton.Config()
c._open_for_reading = mock.Mock(return_value = config_fp)
c.readfp = mock.Mock(return_value = True)
mock_path_exists_func.return_value = True
c.set(burton.Config.root_path, "some_path")
c.set(burton.Config.config_filename, "some_filename")
c.set(burton.Config.platform, "Mac")
self.assertTrue(c._parse_config_file())
c.readfp.assert_called_with(config_fp, "Mac")
c._open_for_reading.assert_called_with(
os.path.join("some_path", "some_filename")
)
def test_returns_false_if_config_file_contains_unknown_variable(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
default_param = 0
overidden_param = 0
[platform1]
overidden_param = 1
other_param = 1
""".replace(" ", ""))
captured_log = testfixtures.LogCapture()
c = burton.Config({ "default_param" : None, "overidden_param" : None })
self.assertFalse(c.readfp(config_fp, "platform1"))
captured_log.check(
(burton.logger_name, "ERROR", "Unable to parse config file"),
(burton.logger_name, "ERROR", "other_param is not a valid option"),
)
captured_log.uninstall()
def test_uses_defaults(self):
config_fp = cStringIO.StringIO("""
[DEFAULT]
[platform1]
""".replace(" ", ""))
c = burton.Config(
config_file_defaults = { "default_param" : '"default_value"' },
command_line_defaults = { "platform" : "Mac", },
command_line_mapping = { "--platform" : [ "platform", "str" ], },
required_command_line_options = [ ],
)
self.assertTrue(c.parse_command_line_options(
"script_name",
[ "some_path" ]
))
self.assertTrue(c.readfp(config_fp, "platform1"))
self.assertEquals(c.get("default_param"), "default_value")
self.assertEquals(c._platform_queue, collections.deque(["Mac"]))
def test_set_and_get(self):
c = burton.Config()
c.set("a_param", 1)
self.assertEquals(c.get("a_param"), 1)
def test_open_for_writing(self, open_func):
c = burton.Config()
c._open_for_writing("filename")
open_func.assert_called_with("filename", "w")
def test_root_path_defaults_to_cwd(self):
c = burton.Config()
c.parse_command_line_options("some_script", [])
self.assertEquals(c.get(burton.Config.root_path), os.getcwd())
def test_parse_command_line_options(self):
c = burton.Config(
command_line_defaults = {
"first_option" : None,
"second_option" : 0,
"third_option" : 0.0,
"fourth_option" : False,
"fifth_option" : False,
"o" : False,
"w" : False,
"t" : False,
burton.Config.print_help : False,
burton.Config.config_filename : "burton.config",
},
command_line_mapping = {
"--option1" : [ "first_option", "str" ],
"--option2" : [ "second_option", "int" ],
"--option3" : [ "third_option", "float", ],
"--option4" : [ "fourth_option", "bool", ],
"--option5" : [ "fifth_option", "bool", ],
"-o" : [ "o", None, ],
"-t" : [ "t", "other", ],
"-w" : [ "w", None, ],
"--help" : [ burton.Config.print_help, None, ],
},
required_command_line_options = [],
)
self.assertTrue(
c.parse_command_line_options(
"script_name",
[
"some_path",
"--option1", "value1",
"--option2", 2,
"--option3", 3.0,
"--option4", "false",
"--option5", 0,
"-o",
"-t", 1,
],
)
)
self.assertEquals(c.get(burton.Config.root_path), "some_path")
self.assertEquals(c.get("first_option"), "value1")
self.assertEquals(c.get("second_option"), 2)
self.assertEquals(c.get("third_option"), 3.0)
self.assertEquals(c.get("fourth_option"), False)
self.assertEquals(c.get("fifth_option"), False)
self.assertEquals(c.get("o"), True)
self.assertEquals(c.get("t"), 1)
self.assertEquals(c.get("w"), False)
captured_log = testfixtures.LogCapture()
self.assertFalse(c.parse_command_line_options(
"script_name",
["--help"]
))
captured_log.check(
(
burton.logger_name,
"ERROR",
"usage: python script_name [path] [arguments]"
),
(
burton.logger_name,
"ERROR",
"This application takes the following arguments"
),
(
burton.logger_name,
"ERROR",
"\n\t".join(c._command_line_mapping.keys())
)
)
captured_log.uninstall()
def test_create_config_instance(self):
self.assertEquals(type(burton._create_config_instance()),
type(burton.Config()))
if return_code == 0:
logger.error("Finished installing dependencies")
logger.error("Run this script again to run localization")
else:
logger.error("Unable to install dependencies")
logger.error("This is most likely a permissions problem")
logger.error("Please try running again with administrator privileges")
logger.error("The exact error(s) are detailed in the output above")
exit(1)
import burton
burton.setup_default_logger()
conf = burton.Config()
if not (conf.parse_command_line_options(sys.argv[0], sys.argv[1:]) and \
conf.parse_config_file_for_next_platform()):
exit(0)
should_use_vcs = conf.get(burton.Config.use_vcs)
vcs_class = burton.vcs.Git()
for filename in os.listdir("."):
if filename.endswith(".xlf"):
import_filename = os.path.join("import", filename)
if os.path.exists(import_filename):
language = filename.split(".")[0]
xlf = burton.translation.XLF(
language,
