def test_main_configs_in_jobs_file(self, print_):
try:
_backupO = backups.Backups()
_backupFilename = _backupO.backup_file(
TEST_PLAYER_JSON, _keep_the_original=True)
# check before changes
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Track Detail"] == 0, \
_player["Graphic Options"]["Track Detail"]
assert _player["Graphic Options"]["Texture Filter"] == 0, \
_player["Graphic Options"]["Texture Filter"]
sys.argv = [
'ScriptedJsonEditor',
r'Tests\jobs_test_configs.json']
_exit_code, _status = ScriptedJsonEditor.main()
# check the changes were made
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Track Detail"] == 1, \
_player["Graphic Options"]["Track Detail"]
assert _player["Graphic Options"]["Texture Filter"] == 4, \
_player["Graphic Options"][""]
finally:
# restore the original player.JSON
_backupO.restore_last_backup(TEST_PLAYER_JSON)
def test_main_key_error_in_jobs_file(self, print_):
_JSNO_O = ScriptedJsonEditor.JsonFile()
try:
_jobs = _JSNO_O._load(
test_test_strings.jobsJSONstrBadKey,
'test_test_strings.jobsJSONstrBadKey')
config = {'rFactor escape slash': True}
except ValueError:
assert False, 'Expected job load to succeed'
assert _jobs
# Execute
# For each job in jobsFile
for job in _jobs["jobs"]:
_j = ScriptedJsonEditor.Job(_jobs["job definitions"][job], config)
# read the file to be edited
_j._load(
test_test_strings.playerJSONstr,
'test_test_strings.playerJSONstr')
# do the edits
# if successful:
# backup 'filepath'
# save new contents to 'filepath
try:
_j.run_edits()
except KeyError:
return # failed as expected, try the next job
except ValueError:
assert False, 'Didn\'t expect ValueError'
except BaseException:
assert False, 'Didn\'t expect other error'
assert False, 'Expected job to fail'
def test_run_job(self):
_jsonJob = ScriptedJsonEditor.JsonJobsFile()
_jsonJob._load(command_line.JOBS_FILE_HELP_STR,
'command_line.JOBS_FILE_HELP_STR')
P_JSON, config = _jsonJob._read()
_jsonJobDefs = ScriptedJsonEditor.JsonJobsDefinitionsFile(config)
_jsonJobDefs._load(command_line.JOB_DEFINITIONS_FILE_HELP_STR,
'test_test_strings.keyboard_jobs_json_file')
_jsonJobDefs._read()
"""
assert P_JSON["job definitions"]["Letterboxing off"] != None
assert P_JSON["job definitions"]["Letterboxing off"]["JSONfileToBeEdited"] != None
assert len(P_JSON["job definitions"]["Letterboxing off"]["edits"]) > 0, P_JSON["job definitions"]["Letterboxing off"]["edits"]
"""
jobs = _jsonJob.get_jobs()
assert len(jobs) > 0
"""
No longer in the same file
assert jobs[0]["JSONfileToBeEdited"] != None
assert len(jobs[0]["edits"]) > 0, jobs[0]["edits"]
"""
for i, job in enumerate(jobs):
_j = ScriptedJsonEditor.Job(job, config)
# read the file to be edited
P_JSON = _j._load(test_test_strings.playerJSONstr,
'test_test_strings.playerJSONstr')
assert P_JSON["Graphic Options"] is not None
assert P_JSON["Graphic Options"][
"Allow HUD in cockpit"] is not None
assert P_JSON["Graphic Options"]["Allow HUD in cockpit"], P_JSON[
"Graphic Options"]["Allow HUD in cockpit"]
# before job
assert _j._get_value("Graphic Options",
"Allow Letterboxing"), _j._get_value(
"Graphic Options", "Allow Letterboxing")
# do the edits
_j.run_edits()
if i == 0:
assert _j._get_value(
"Graphic Options",
"Allow Letterboxing") == False, _j._get_value(
"Graphic Options", "Allow Letterboxing")
else:
assert _j._get_value("Graphic Options",
"Automap") == 2, _j._get_value(
"Graphic Options", "Automap")
def test_jobs2base(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
_JSNO_O._load(test_test_strings.jobs2base,
'test_test_strings.jobs2base')
P_JSON, config = _JSNO_O._read()
assert P_JSON["jobs"] is not None
for j in P_JSON["jobs"]:
assert P_JSON["job definitions"][j] is not None
def test_main_bad_jobs_file(self, print_):
_JSNO_O = ScriptedJsonEditor.JsonFile()
try:
_jobs = _JSNO_O._load(
test_test_strings.jobsBadJSONstr,
'test_test_strings.jobsBadJSONstr')
except ValueError:
return
assert False, 'Expected job load to fail'
def test_edit_job_file(self):
_jsonJob = ScriptedJsonEditor.JsonJobsFile()
_jsonJob._load(command_line.JOBS_FILE_HELP_STR,
'command_line.JOBS_FILE_HELP_STR')
P_JSON, __ = _jsonJob._read()
# Copy JOBS_FILE_HELP_STR and edit it - or just use EDITED_JOBS_FILE_HELP_STR
# Run edit_job_file
# _write it to a string??
# compare to the edited JOBS_FILE_HELP_STR
_jsonJob._edit_job_file(EDITS)
# _jsonJob._write()
P_JSON_edited, __ = _jsonJob._read()
_jsonJobTest = ScriptedJsonEditor.JsonJobsFile()
_jsonJobTest._load(EDITED_JOBS_FILE_HELP_STR,
'EDITED_JOBS_FILE_HELP_STR')
P_JSON_TEST_STR, __ = _jsonJobTest._read()
self.assertEqual(P_JSON_edited, P_JSON_TEST_STR)
def test_load_JSON_str(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
_JSNO_O._load(test_test_strings.jobsJSONstr1,
'test_test_strings.jobsJSONstr1')
P_JSON, config = _JSNO_O._read()
assert P_JSON["job definitions"]["job1"] is not None
assert P_JSON["job definitions"]["job1"][
"JSONfileToBeEdited"] is not None
assert len(P_JSON["job definitions"]["job1"]
["edits"]) > 0, P_JSON["job definitions"]["job1"]["edits"]
def test_jobsDefinition_realFile(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(test_config)
filepath = this_path(
os.path.join('..', 'job_definitions', 'Keyboard_jobs.json'))
jobDefinitions = _JSNO_O.read(filepath)
assert "Cursor keys control seat" in jobDefinitions['Keyboard_jobs']
assert "Driver aid buttons disable" in jobDefinitions['Keyboard_jobs']
assert jobDefinitions['Keyboard_jobs']["Cursor keys control seat"][
"JSONfileToBeEdited"] == test_config["<CONTROLLER.JSON>"]
def test_2jobsDefinition(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(test_config)
_JSNO_O._load(test_test_strings.jobDefinition,
'test_test_strings.jobDefinition')
jobDefinitions = _JSNO_O._read()
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(test_config)
_JSNO_O._load(test_test_strings.jobDefinition2,
'test_test_strings.jobDefinition2')
jobDefinitions.update(_JSNO_O._read())
assert "VR" in jobDefinitions['test_test_strings.jobDefinition']
assert "G25 minor controls" in jobDefinitions[
'test_test_strings.jobDefinition']
assert jobDefinitions['test_test_strings.jobDefinition']["VR"][
"JSONfileToBeEdited"] == test_config["<CONTROLLER.JSON>"]
assert "Wheel settings" in jobDefinitions[
'test_test_strings.jobDefinition2']
assert jobDefinitions['test_test_strings.jobDefinition2'][
"Wheel settings"]["JSONfileToBeEdited"] == test_config[
"<CONTROLLER.JSON>"]
def test_jobsJSONfileToBeEdited(self):
job_definition_filename = 'test_test_strings.jobsJSONfileToBeEdited'
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(test_config)
_JSNO_O._load(test_test_strings.jobsJSONfileToBeEdited,
job_definition_filename)
P_JSON = _JSNO_O._read()
assert P_JSON[job_definition_filename][
"jobJSONfileToBeEdited"] is not None
assert P_JSON[job_definition_filename]["jobJSONfileToBeEdited"]["JSONfileToBeEdited"] == "test/player.json", \
P_JSON[job_definition_filename]["jobJSONfileToBeEdited"]["JSONfileToBeEdited"]
def test_jobsDefinition_w_macros(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(
test_config_w_macros)
_JSNO_O._load(test_test_strings.jobDefinition,
'test_test_strings.jobDefinition')
jobDefinitions = _JSNO_O._read()
assert "VR" in jobDefinitions['test_test_strings.jobDefinition']
assert "G25 minor controls" in jobDefinitions[
'test_test_strings.jobDefinition']
assert jobDefinitions['test_test_strings.jobDefinition']["VR"][
"JSONfileToBeEdited"] == test_config_w_macros["<CONTROLLER.JSON>"]
def test_jobsConfig(self):
# Jobs file with config specified
filepath = this_path('jobs_test_configs.json')
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
P_JSON, config = _JSNO_O.read(filepath)
assert P_JSON["jobs"] is not None
for j in P_JSON["jobs"]:
# Not sure what this was testing
assert j is not None
assert config["<PLAYER.JSON>"] == r'Tests\player.JSON', config[
"<PLAYER.JSON>"]
def test_using_test_dict(self):
if os.path.exists(PLAYER_JSON):
_JSNO_O = ScriptedJsonEditor.JsonFile()
P_JSON = _JSNO_O.read(PLAYER_JSON)
##################################
# change values as required
##################################
for key, item, newValue in EDITS_EXAMPLE:
_JSNO_O.edit(key, item, newValue)
_PLAYER_JSON = PLAYER_JSON + '.edited'
_JSNO_O.write(_PLAYER_JSON)
assert os.path.exists(_PLAYER_JSON), _PLAYER_JSON
def test_newJobsFile(self):
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
_JSNO_O._load(test_test_strings.jobsNewJSONfile,
'test_test_strings.jobsNewJSONfile')
P_JSON, config = _JSNO_O._read()
jobDefinitions = {}
for _job_definition_file in P_JSON["job definition files"]:
_x = _JSNO_O.read(_job_definition_file)
jobDefinitions.update(_x[0]['job definitions'])
for _job_set in P_JSON["jobs"]:
for _job_definition_file in _job_set:
for _job in _job_set[_job_definition_file]:
assert _job in jobDefinitions, _job
def test_whole_example_job(self):
sys.argv = ['ScriptedJsonEditor', 'jobs\\VR_G25.json']
try:
_backupO = backups.Backups()
_backupFilename = _backupO.backup_file(PLAYER_JSON,
_keep_the_original=True)
_backupFilename = _backupO.backup_file(CONTROLLER_JSON,
_keep_the_original=True)
_exit_code, _status = ScriptedJsonEditor.main()
# check the changes were made
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(PLAYER_JSON)
#assert _player["Graphic Options"]["Allow Letterboxing"] == False, _player["Graphic Options"]["Allow Letterboxing"]
#assert _player["Graphic Options"]["Automap"] == 3, _player["Graphic Options"]["Automap"]
finally:
# restore the original player.JSON
_backupO.restore_last_backup(PLAYER_JSON)
_backupO.restore_last_backup(CONTROLLER_JSON)
assert _exit_code == 0
def test_main_JSONfileToBeEdited(self):
sys.argv = ['ScriptedJsonEditor', 'jobs\\VR.json']
_clo = command_line.CommandLine()
jobsFile = _clo.get_jobs_file()
if jobsFile:
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
__, config = _JSNO_O.read(jobsFile)
_jobs = _JSNO_O.get_jobs()
if _jobs:
# Execute
# For each job in jobsFile
for job in _jobs:
_j = ScriptedJsonEditor.Job(job, config)
# read the file to be edited
_j._load(
test_test_strings.playerJSONstr,
'test_test_strings.playerJSONstr')
else:
assert False, 'No jobs in jobs\\VR.json'
else:
assert False, r'No jobsfile jobs\VR.json'
def test_get_job_definitions(self):
config = {
"<CONTROLLER.JSON>":
"c:\\Program Files (x86)\\Steam\\steamapps\\common\\rFactor 2\\UserData\\Player\\Controller.JSON"
}
_jsonJob = ScriptedJsonEditor.JsonJobsDefinitionsFile(config)
P_JSON = _jsonJob._load(command_line.JOB_DEFINITIONS_FILE_HELP_STR,
'command_line.JOB_DEFINITIONS_FILE_HELP_STR')
assert P_JSON["job definitions"]["Letterboxing off"] is not None
assert P_JSON["job definitions"]["Letterboxing off"][
"JSONfileToBeEdited"] is not None
assert len(
P_JSON["job definitions"]["Letterboxing off"]["edits"]
) > 0, P_JSON["job definitions"]["Letterboxing off"]["edits"]
"""
def test_editJson(self):
if os.path.exists(filepath):
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_JSNO_O.read(filepath)
##################################
# change values as required
##################################
for key, item, newValue in test_test_strings.edits:
try:
_JSNO_O.edit(key, item, newValue)
except KeyError: # we're expecting one error
assert key == 'GraphicOptions', key
_filepath = filepath + '.edited'
_JSNO_O.write(_filepath)
def test_load_JSON_str_2jobs(self):
job_definition_filename = 'test_test_strings.jobsJSONstrBadKey2'
_JSNO_O = ScriptedJsonEditor.JsonJobsDefinitionsFile(test_config)
_JSNO_O._load(test_test_strings.jobsJSONstrBadKey2,
job_definition_filename)
P_JSON = _JSNO_O._read()
assert P_JSON[job_definition_filename]["job1"] is not None
assert P_JSON[job_definition_filename]["job1"][
"JSONfileToBeEdited"] is not None
assert len(P_JSON[job_definition_filename]["job1"]["edits"]
) > 0, P_JSON[job_definition_filename]["job1"]["edits"]
assert P_JSON[job_definition_filename]["job2"] is not None
assert P_JSON[job_definition_filename]["job2"][
"JSONfileToBeEdited"] is not None
assert len(P_JSON[job_definition_filename]["job2"]["edits"]
) > 0, P_JSON[job_definition_filename]["job2"]["edits"]
def test_main(self, print_): # Note added , print_ to mock print()
try:
_backupO = backups.Backups()
_backupFilename = _backupO.backup_file(
TEST_PLAYER_JSON, _keep_the_original=True)
# check before changes
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Allow Letterboxing"], \
_player["Graphic Options"]["Allow Letterboxing"]
assert _player["Graphic Options"]["Automap"] == 3, \
_player["Graphic Options"]["Automap"]
sys.argv = ['ScriptedJsonEditor', r'Tests\jobs_test1.json']
_exit_code, _status = ScriptedJsonEditor.main()
# check the changes were made
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Allow Letterboxing"] == False, \
_player["Graphic Options"]["Allow Letterboxing"]
assert _player["Graphic Options"]["Automap"] == 2, \
_player["Graphic Options"]["Automap"]
finally:
# restore the original player.JSON
_backupO.restore_last_backup(TEST_PLAYER_JSON)
assert _exit_code == 0
# Mock the print call in main()
@patch('ScriptedJsonEditor.print', create=True)
# Note added , print_ to mock print()
def test_main_configs_in_jobs_file(self, print_):
try:
_backupO = backups.Backups()
_backupFilename = _backupO.backup_file(
TEST_PLAYER_JSON, _keep_the_original=True)
# check before changes
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Track Detail"] == 0, \
_player["Graphic Options"]["Track Detail"]
assert _player["Graphic Options"]["Texture Filter"] == 0, \
_player["Graphic Options"]["Texture Filter"]
sys.argv = [
'ScriptedJsonEditor',
r'Tests\jobs_test_configs.json']
_exit_code, _status = ScriptedJsonEditor.main()
# check the changes were made
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_player = _JSNO_O.read(TEST_PLAYER_JSON)
assert _player["Graphic Options"]["Track Detail"] == 1, \
_player["Graphic Options"]["Track Detail"]
assert _player["Graphic Options"]["Texture Filter"] == 4, \
_player["Graphic Options"][""]
finally:
# restore the original player.JSON
_backupO.restore_last_backup(TEST_PLAYER_JSON)
assert _exit_code == 0
def test_readJsonFile(self):
if os.path.exists(filepath):
_JSNO_O = ScriptedJsonEditor.JsonRfactorFile()
_JSNO_O.read(filepath)
_filepath = filepath + '.mostlySame'
_JSNO_O.write(_filepath)
def test_main_non_existent_jobs_file(self, print_):
sys.argv = ['ScriptedJsonEditor', 'JsonEditorJobs.json']
assert ScriptedJsonEditor.main()[0] != 0
def test_read_file(self):
filepath = this_path('jobs_test1.json')
_JSNO_O = ScriptedJsonEditor.JsonJobsFile()
P_JSON, config = _JSNO_O.read(filepath)
assert P_JSON["job definition files"] is not None
assert len(P_JSON["jobs"]) > 0, P_JSON["job definitions"]["jobs"]