def test_ConfigLoader_revert_to_default_creates_files_and_directories(
self):
home_to_delete = os.path.abspath('delete_me')
save_config({'home_directory': home_to_delete})
new = ConfigLoader()
home = os.path.join(get_documents_folder(), APP_NAME)
self.assertFalse(os.path.exists(home))
for filename in [
VERBS_CSV, COUNTABLE_NOUNS_CSV, UNCOUNTABLE_NOUNS_CSV
]:
self.assertTrue(
os.path.exists(os.path.join(home_to_delete, filename)))
new.revert_to_default()
for filename in [
VERBS_CSV, COUNTABLE_NOUNS_CSV, UNCOUNTABLE_NOUNS_CSV
]:
self.assertTrue(
os.path.exists(os.path.join(home_to_delete, filename)))
self.assert_default_ConfigLoader_state(new)
rmtree(home_to_delete)
def test_ConfigLoader_init_existing_config_file_existing_files(self):
home = os.path.abspath('to_delete')
save = os.path.abspath('bogus_save')
existing_verbs = os.path.join(home, 'my_verb.csv')
if not os.path.exists(home):
os.mkdir(home)
if not os.path.exists(save):
os.mkdir(save)
with open(existing_verbs, 'w') as f:
f.write('exists')
save_config({
'home_directory': home,
'save_directory': save,
'verbs': existing_verbs
})
new = ConfigLoader()
self.assert_ConfigLoader_state(new, home, save, VERBS_CSV)
with open(existing_verbs, 'r') as f:
self.assertEqual(f.read(), 'exists')
self.assertEqual(new.state['verbs'], existing_verbs)
rmtree(home)
rmtree(save)
def test_reload_files(self):
ConfigLoader()
save_config({
'probability_plural_noun': 0,
'probability_negative_verb': 0,
'probability_pronoun': 0
})
new_verb = Verb('boogahboogah').third_person()
new_noun = Noun('wackawacka').definite()
main = MainFrame()
with open(os.path.join(APP_FOLDER, COUNTABLE_NOUNS_CSV), 'w') as f:
f.write('wackawacka')
with open(os.path.join(APP_FOLDER, UNCOUNTABLE_NOUNS_CSV), 'w') as f:
f.write('')
with open(os.path.join(APP_FOLDER, VERBS_CSV), 'w') as f:
f.write('boogahboogah')
paragraph = main.paragraph_generator.create_paragraph()
for sentence in paragraph:
self.assertNotIn(new_noun, sentence)
self.assertNotIn(new_verb, sentence)
main.reload_files()
paragraph = main.paragraph_generator.create_paragraph()
for sentence in paragraph:
self.assertIn(new_noun, sentence)
self.assertIn(new_verb, sentence)
def test_ConfigLoader_reload_home_directory_change_NEEDS_TO_UPDATE_FULL_CONFIG(
self):
new = ConfigLoader()
new_home = os.path.abspath('delete_me')
old_home = os.path.join(get_documents_folder(), APP_NAME)
save_config({'home_directory': new_home})
new.reload()
to_check = {
'countable_nouns': COUNTABLE_NOUNS_CSV,
'uncountable_nouns': UNCOUNTABLE_NOUNS_CSV,
'verbs': VERBS_CSV
}
for key, filename in to_check.items():
self.assertEqual(new.state[key], os.path.join(new_home, filename))
with open(os.path.join(DATA_PATH, filename), 'r') as default:
default_text = default.read()
with open(os.path.join(old_home, filename), 'r') as old_file:
self.assertEqual(old_file.read(), default_text)
with open(os.path.join(new_home, filename), 'r') as new_file:
self.assertEqual(new_file.read(), default_text)
rmtree(new_home)
def test_ConfigLoader_set_up_frame_PctSpinBox_no_error_with_int(self):
# Default: 'error_probability' = 0.02
ed = ErrorDetails()
save_config({'error_probability': 10})
loader = ConfigLoader()
loader.set_up_frame(ed)
self.assertEqual(ed.get_values()['error_probability'], 0.10)
def test_load_config(self):
main = MainFrame()
save_config({'probability_plural_noun': 0})
loader = ConfigLoader()
self.assertNotEqual(loader.state, main.get_state())
main.load_config()
self.assertEqual(loader.state, main.get_state())
def test_ConfigLoader_init_existing_config_fails_when_directory_parent_not_there_message(
self):
home = 'not_there/really_not_there'
save_config({'home_directory': home})
with self.assertRaises(ConfigFileError) as context:
ConfigLoader()
error = context.exception
msg = 'Config Loader failed to create the following directory:\n'
msg += os.path.abspath(home)
self.assertIn(msg, error.args[0])
def test_ConfigLoader_set_up_frame_raises_ConfigFileError_bool(self):
# Default: 'verb_errors' = True
ed = ErrorDetails()
save_config({'verb_errors': 'hello'})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, ed)
save_config({'verb_errors': 10.0})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, ed)
def test_ConfigLoader_set_up_frame_raises_ConfigFileError_int(self):
# Default: 'subject_pool' = 5
pt = ParagraphType()
save_config({'subject_pool': 'hello'})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, pt)
save_config({'subject_pool': 10.0})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, pt)
def test_ConfigLoader_set_up_frame_raises_ConfigFileError_float(self):
# Default: 'error_probability' = 0.02
ed = ErrorDetails()
save_config({'error_probability': 'hi'})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, ed)
save_config({'error_probability': None})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, ed)
def test_load_config_from_file_empty_string_does_nothing(
self, mock_filename):
main = MainFrame()
save_config({'probability_plural_noun': 0.0})
main.load_config()
current_state = main.get_state()
mock_filename.return_value = ''
main.load_config_from_file()
self.assertEqual(current_state, main.get_state())
def test_ConfigLoader_init_existing_config_file_non_existent_directories_only_if_parent_path_exists(
self):
home = os.path.abspath('to_delete')
save = os.path.join(home, 'bogus_save')
save_config({'home_directory': home, 'save_directory': save})
new = ConfigLoader()
self.assert_ConfigLoader_state(new, home, save)
# cleanup
rmtree(home)
def test_save_config(self):
with open(DEFAULT_CONFIG, 'r') as f:
default_text = f.read()
save_config({'paragraph_type': 'bobo', 'paragraph_size': 10})
with open(CONFIG_FILE, 'r') as f:
config_text = f.read()
answer = default_text.replace('paragraph_size = 15',
'paragraph_size = 10')
answer = answer.replace('paragraph_type = chain',
'paragraph_type = bobo')
self.assertEqual(answer, config_text)
def test_create_text_error_pool_not_large_enough(self, mock_error):
ConfigLoader() # set up directories
save_config({'paragraph_type': 'pool', 'probability_pronoun': 0})
for file_name in (UNCOUNTABLE_NOUNS_CSV, COUNTABLE_NOUNS_CSV):
with open(os.path.join(APP_FOLDER, file_name), 'w') as f:
f.write('dog')
main = MainFrame()
main.create_texts()
mock_error.assert_called_with(
'Uh-oh!',
'ValueError: pool size is too large for available nouns loaded from file'
)
def test_WARNING_ConfigLoader_set_up_frame_int_and_pct_edge_case_with_bool_WARNING(
self):
# 'subject_pool' minimum = 2
# 'error_probability' minimum = 0.0
pt = ParagraphType()
ed = ErrorDetails()
save_config({'subject_pool': True, 'error_probability': True})
loader = ConfigLoader()
loader.set_up_frame(pt)
loader.set_up_frame(ed)
self.assertEqual(pt.get_values()['subject_pool'], 2)
self.assertEqual(ed.get_values()['error_probability'], 0.0)
def test_ConfigLoader_set_up_frame_bool_no_error_with_int(self):
# Default: 'verb_errors' = True
ed = ErrorDetails()
save_config({'verb_errors': 0})
loader = ConfigLoader()
loader.set_up_frame(ed)
self.assertEqual(ed.get_values()['verb_errors'], False)
save_config({'verb_errors': 2})
loader = ConfigLoader()
loader.set_up_frame(ed)
self.assertEqual(ed.get_values()['verb_errors'], True)
def test_change_file_bad_file_by_config(self, mock_error):
bad_file = os.path.join(DATA_PATH, 'go_time.ico')
main = MainFrame()
for count, key in enumerate(
('countable_nouns', 'uncountable_nouns', 'verbs')):
self.assertEqual(mock_error.call_count, count)
main.revert_to_original()
save_config({key: bad_file})
main.load_config()
message = (
'LoaderError: Could not read CSV file. ' +
'If you edited it in MSWord or something similar, it got formatted. Use "notepad"'
)
mock_error.assert_called_with('Bad file', message)
self.assertEqual(mock_error.call_count, count + 1)
def test_create_texts_creates_files(self):
prefix = 'adjjk409dvc'
main = MainFrame()
save_config({'file_prefix': prefix})
main.load_config()
main.do_not_show_popup.set(1)
main.create_texts()
self.assertTrue(
os.path.exists(
os.path.join(APP_FOLDER, DEFAULT_SAVE_DIR,
prefix + '01_answer.pdf')))
self.assertTrue(
os.path.exists(
os.path.join(APP_FOLDER, DEFAULT_SAVE_DIR,
prefix + '01_error.pdf')))
def test_load_config_error_reverts(self, mock_error):
main = MainFrame()
default_state = main.get_state()
save_config({'probability_plural_noun': 0.0})
main.load_config()
self.assertNotEqual(main.get_state(), default_state)
save_config({'probability_plural_noun': 'oops'})
main.load_config()
mock_error.assert_called_with(
'bad config',
"ConfigFileError: Tried to set key: 'probability_plural_noun' to incompatible value: 'oops'."
)
self.assertEqual(main.get_state(), default_state)
def test_revert_to_original(self):
ConfigLoader() # set up directories
save_config({'probability_pronoun': 0})
with open(DEFAULT_CONFIG, 'r') as default:
with open(CONFIG_FILE, 'r') as current:
self.assertNotEqual(default.read(), current.read())
verb_file = os.path.join(APP_FOLDER, VERBS_CSV)
with open(verb_file, 'w') as f:
f.write('go')
main = MainFrame()
main.revert_to_original()
with open(DEFAULT_CONFIG, 'r') as default:
with open(CONFIG_FILE, 'r') as current:
self.assertEqual(default.read(), current.read())
with open(os.path.join(DATA_PATH, VERBS_CSV), 'r') as default:
with open(verb_file, 'r') as current:
self.assertEqual(default.read(), current.read())
def test_ConfigLoader_reload_home_directory_change(self):
new = ConfigLoader()
new_home = os.path.abspath('delete_me')
old_home = os.path.join(get_documents_folder(), APP_NAME)
full_config = new.state
full_config.update({'home_directory': new_home})
self.assertNotEqual(full_config, new.state)
save_config(full_config)
new.reload()
self.assertEqual(full_config, new.state)
for filename in [
COUNTABLE_NOUNS_CSV, UNCOUNTABLE_NOUNS_CSV, VERBS_CSV
]:
with open(os.path.join(DATA_PATH, filename), 'r') as default:
with open(os.path.join(old_home, filename), 'r') as target:
self.assertEqual(default.read(), target.read())
# new_home should be empty. If this raises an error, there's something very wrong.
os.rmdir(new_home)
def test_export_config_file_saves_correctly(self, mock_filename):
filename = os.path.join(TESTS_FILES, 'tst.cfg')
if os.path.exists(filename):
os.remove(filename)
main = MainFrame()
default_state = main.get_state()
save_config({'font_size': 15})
main.load_config()
current_state = main.get_state()
ConfigLoader().revert_to_default()
config_state = ConfigLoader().state
expected_state = config_state.copy()
expected_state['font_size'] = 15
# test current state
self.assertEqual(default_state, config_state)
self.assertEqual(current_state, expected_state)
self.assertNotEqual(default_state, current_state)
mock_filename.return_value = filename
main.export_config_file()
saved_config = ConfigLoader()
saved_config.set_state_from_file(filename)
config_file_state = ConfigLoader().state
self.assertEqual(saved_config.state, current_state)
self.assertEqual(main.get_state(), current_state)
self.assertEqual(config_file_state, default_state)
mock_filename.assert_called_with(
initialdir=current_state['home_directory'],
title='select .cfg file',
initialfile='exported_config.cfg',
defaultextension='.cfg')
os.remove(filename)
def test_ConfigLoader_init_existing_config_file_non_existent_files(self):
home = os.path.abspath('to_delete')
save = os.path.abspath('bogus_save')
existing_verbs = os.path.join(home, 'not_really_there.csv')
if not os.path.exists(home):
os.mkdir(home)
if not os.path.exists(save):
os.mkdir(save)
save_config({
'home_directory': home,
'save_directory': save,
'verbs': existing_verbs
})
new = ConfigLoader()
self.assert_ConfigLoader_state(new, home, save)
# cleanup
rmtree(home)
rmtree(save)
def test_load_config_from_file_bad_file_without_reset(
self, mock_filename, mock_error):
filename = os.path.join(TESTS_FILES, 'tst.cfg')
bad_path = os.path.join(TESTS_FILES, 'nope', 'really_nope')
mock_filename.return_value = filename
save_config_to_filename({'save_directory': bad_path}, filename)
main = MainFrame()
save_config({'probability_plural_noun': 0.0})
main.load_config()
current_state = main.get_state()
main.load_config_from_file()
self.assertEqual(main.get_state(), current_state)
self.assertEqual(mock_error.call_args[0][0], 'bad config file')
msg = "ConfigFileError: Config Loader failed to create the following directory:\n"
self.assertIn(msg, mock_error.call_args[0][1])
os.remove(filename)
def test_load_config_from_file_bad_file_with_reset(self, mock_filename,
mock_error):
filename = os.path.join(TESTS_FILES, 'tst.cfg')
mock_filename.return_value = filename
save_config_to_filename({'probability_plural_noun': 'oops'}, filename)
main = MainFrame()
default_state = main.get_state()
save_config({'probability_plural_noun': 0.0})
main.load_config()
main.load_config_from_file()
self.assertEqual(main.get_state(), default_state)
mock_error.assert_called_with(
'bad config file',
"ConfigFileError: Tried to set key: 'probability_plural_noun' to incompatible value: 'oops'."
)
os.remove(filename)
def test_ConfigLoader_set_up_frame_raises_ConfigFileError_string(self):
# Default: 'paragraph_type' = 'chain'
pt = ParagraphType()
save_config({'paragraph_type': 1})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, pt)
save_config({'paragraph_type': True})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, pt)
save_config({'paragraph_type': None})
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_up_frame, pt)
def set_config(self):
save_config(self.get_state())
def test_ConfigLoader_init_existing_config_fails_when_directory_parent_not_there_save_directory(
self):
save = 'not_there/really_not_there'
save_config({'save_directory': save})
self.assertRaises(ConfigFileError, ConfigLoader)
