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_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_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_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_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_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_GrammarDetails(self):
gd = GrammarDetails()
loader = ConfigLoader()
loader.set_up_frame(gd)
answer = {
'tense': 'simple_present',
'probability_plural_noun': 0.3,
'probability_negative_verb': 0.3,
'probability_pronoun': 0.2
}
self.assertEqual(gd.get_values(), answer)
def load_config_from_file(self):
loader = ConfigLoader()
filename = askopenfilename(
initialdir=self.get_state()['home_directory'],
title='select .cfg file',
defaultextension='.cfg')
if not filename:
return None
loader.set_state_from_file(filename)
self._load_new_state(loader)
def test_ConfigLoader_set_up_frame_ParagraphType(self):
pt = ParagraphType()
loader = ConfigLoader()
loader.set_up_frame(pt)
answer = {
'paragraph_type': 'chain',
'subject_pool': 5,
'num_paragraphs': 4,
'paragraph_size': 15
}
self.assertEqual(pt.get_values(), answer)
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_ErrorDetails(self):
ed = ErrorDetails()
loader = ConfigLoader()
loader.set_up_frame(ed)
answer = {
'error_probability': 0.2,
'noun_errors': True,
'pronoun_errors': False,
'verb_errors': True,
'is_do_errors': False,
'preposition_transpose_errors': False,
'punctuation_errors': True
}
self.assertEqual(ed.get_values(), answer)
def test_ConfigLoader_set_up_frame_FileManagement(self):
fm = FileManagement()
loader = ConfigLoader()
loader.set_up_frame(fm)
home = os.path.join(get_documents_folder(), APP_NAME)
answer = {
'home_directory': home,
'save_directory': os.path.join(home, DEFAULT_SAVE_DIR),
'countable_nouns': os.path.join(home, COUNTABLE_NOUNS_CSV),
'uncountable_nouns': os.path.join(home, UNCOUNTABLE_NOUNS_CSV),
'proper_nouns': os.path.join(home, PROPER_NOUNS_CSV),
'verbs': os.path.join(home, VERBS_CSV)
}
self.assertEqual(fm.get_values(), answer)
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 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_ConfigLoader_init_whole_state(self):
answer = ConfigLoader().state
home = os.path.join(get_documents_folder(), APP_NAME)
expected = {
'home_directory': home,
'save_directory': os.path.join(home, DEFAULT_SAVE_DIR),
'countable_nouns': os.path.join(home, COUNTABLE_NOUNS_CSV),
'uncountable_nouns': os.path.join(home, UNCOUNTABLE_NOUNS_CSV),
'proper_nouns': os.path.join(home, PROPER_NOUNS_CSV),
'verbs': os.path.join(home, VERBS_CSV),
'error_probability': 0.2,
'noun_errors': True,
'pronoun_errors': False,
'verb_errors': True,
'punctuation_errors': True,
'is_do_errors': False,
'preposition_transpose_errors': False,
'tense': 'simple_present',
'probability_plural_noun': 0.3,
'probability_negative_verb': 0.3,
'probability_pronoun': 0.2,
'paragraph_type': 'chain',
'subject_pool': 5,
'num_paragraphs': 4,
'paragraph_size': 15,
'font_size': 13,
'file_prefix': ''
}
self.assertEqual(answer, expected)
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_create_texts_missing_words(self, mock_error):
ConfigLoader()
with open(os.path.join(APP_FOLDER, VERBS_CSV), 'w') as f:
f.write('')
MainFrame().create_texts()
mock_error.assert_called_with(
'Uh-oh!', 'ValueError: There are no verbs in the verb list.')
def test_ConfigLoader_set_state_from_file_missing_file_ConfigFileError(
self):
filename = os.path.join(TESTS_FILES, 'not_there.cfg')
if os.path.exists(filename):
os.remove(filename)
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_state_from_file,
filename)
def test_set_config(self):
main = MainFrame()
with open(os.path.join(DATA_PATH, CONFIG_FILE), 'w') as f:
f.write('')
self.assertRaises(KeyError, ConfigLoader)
main.set_config()
self.assertEqual(main.get_state(), ConfigLoader().state)
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_load_config_from_file_loads_from_file(self, mock_filename):
filename = os.path.join(TESTS_FILES, 'tst.cfg')
mock_filename.return_value = filename
save_config_to_filename({'probability_plural_noun': 0.0}, filename)
main = MainFrame()
default_state = main.get_state()
main.load_config_from_file()
self.assertNotEqual(main.get_state(), default_state)
loader = ConfigLoader()
loader.set_state_from_file(filename)
self.assertEqual(loader.state, main.get_state())
os.remove(filename)
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_state_from_file_bad_file_ConfigFileError(self):
filename = os.path.join(TESTS_FILES, 'tst.cfg')
bad_text = 'no comment and no equal'
with open(filename, 'w') as f:
f.write(bad_text)
loader = ConfigLoader()
self.assertRaises(ConfigFileError, loader.set_state_from_file,
filename)
# cleanup
os.remove(filename)
def test_ConfigLoader_set_state_from_file_no_errors(self):
filename = os.path.join(TESTS_FILES, 'test.cfg')
save_config_to_filename({'error_probability': 1.0},
filename) # default 0.20
loader = ConfigLoader()
loader.set_state_from_file(filename)
default_loader = ConfigLoader()
loader_state = loader.state
default_state = default_loader.state
self.assertNotEqual(loader_state, default_state)
self.assertEqual(loader_state['error_probability'], 1.0)
loader_state['error_probability'] = 0.20
self.assertEqual(loader_state, default_state)
# cleanup
os.remove(filename)
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 alphabetize(file_name, replace=True):
if not os.path.exists(file_name):
loader = ConfigLoader()
file_name = os.path.join(loader.state['home_directory'], file_name)
lst = load_file(file_name)
if replace:
new_name = file_name
else:
new_name = file_name.replace('.csv', '_sorted.csv')
write_file(new_name, lst)
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_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_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_ConfigLoader_revert_to_default_resets_csvs_but_leaves_other_files(
self):
new = ConfigLoader()
home = os.path.join(get_documents_folder(), APP_NAME)
save = os.path.join(home, DEFAULT_SAVE_DIR)
home_files = [VERBS_CSV, COUNTABLE_NOUNS_CSV, 'foo.txt', 'bar.txt']
save_files = ['foo.txt', 'bar.txt']
write_files = [os.path.join(home, filename) for filename in home_files]
write_files += [
os.path.join(save, filename) for filename in save_files
]
files_not_reset = write_files[2:]
for filename in write_files:
with open(filename, 'w') as f:
f.write('foobar')
new.revert_to_default()
self.assert_default_ConfigLoader_state(new)
for filename in files_not_reset:
with open(filename, 'r') as f:
self.assertEqual(f.read(), 'foobar')
