def test_wrap_index_error(self):
vp = VarietyPopulator(file1_path)
num_entries = vp.get_num_variations('greeting')
entries = []
for i in range(num_entries):
entries.append(vp.get_replacement(
'greeting',
index=i,
))
for i in range(100):
self.assertEqual(
entries[i % num_entries],
vp.get_replacement(
'greeting',
index=i,
is_wrap_index=True,
))
for i in range(num_entries + 1, 100):
self.assertRaises(
IndexError,
vp.get_replacement,
'greeting',
index=i,
is_wrap_index=False,
)
def test_duplicate_items(self):
dict1 = """
{"foo": ["foo", "foo", "bar"]}
"""
dict2 = """
{"foo": ["foo"],
"bar": ["foo", "bar", "foobar"],
"foobar": "foo-bar"
}
"""
expected_dict = {
"foo": ["foo", "bar"],
"bar": ["foo", "bar", "foobar"],
"foobar": ["foo-bar"]
}
with mock.patch('builtins.open', mock.mock_open(read_data=dict1)):
vp_dict = VarietyPopulator._create_dict("variety.json")
self.assertEqual(len(expected_dict["foo"]), len(vp_dict["foo"]))
self.assertIn("foo", vp_dict["foo"])
self.assertIn("bar", vp_dict["foo"])
with mock.patch('builtins.open',
mock.mock_open(read_data=dict1)) as mock_open:
handlers = [
mock_open.return_value,
mock.mock_open(read_data=dict2).return_value
]
mock_open.side_effect = handlers
vp_dict = VarietyPopulator._create_dict(
files=["file1.json", "file2.json"])
self.assertEqual(len(expected_dict), len(vp_dict))
for key in vp_dict:
self.assertEqual(len(expected_dict[key]), len(vp_dict[key]))
def test_get_replacement(self):
vp = VarietyPopulator(file1_path)
num_entries = vp.get_num_variations('greeting')
self.assertEqual(3, num_entries)
entries = []
for i in range(num_entries):
entries.append(vp.get_replacement(
'greeting',
index=i,
))
for _ in range(100):
self.assertTrue(vp.get_replacement('greeting') in entries)
def test_wildcard_symbol(self):
vp = VarietyPopulator(file1_path)
tag = 'greeting*'
num_entries = vp.get_num_variations(tag)
self.assertEqual(4, num_entries)
entries = []
for i in range(num_entries):
entries.append(vp.get_replacement(
tag,
index=i,
))
tag = '*question'
num_entries = vp.get_num_variations(tag)
self.assertEqual(5, num_entries)
entries = []
for i in range(num_entries):
entries.append(vp.get_replacement(
tag,
index=i,
))
tag = '*part*'
num_entries = vp.get_num_variations(tag)
self.assertEqual(2, num_entries)
entries = []
for i in range(num_entries):
entries.append(vp.get_replacement(
tag,
index=i,
))
def test_create_dict_from_file(self):
variation_dict = VarietyPopulator._create_dict(file1_path)
for k in ['greeting', 'question', 'foo', 'foobar', 'fakebar']:
self.assertTrue(k in variation_dict)
self.assertEqual(3, len(variation_dict['greeting']))
self.assertEqual(4, len(variation_dict['question']))
self.assertEqual('fake-bar', variation_dict['fakebar'][0])
def test_create_dict_from_multiple_files(self):
variation_dict1 = VarietyPopulator._create_dict(
[file1_path, file2_path])
variation_dict2 = VarietyPopulator._create_dict(file1_path)
variation_dict2 = VarietyPopulator._create_dict(
file2_path, variation_dict2)
variation_dict3 = VarietyPopulator._create_dict(file2_path)
variation_dict3 = VarietyPopulator._create_dict(
file1_path, variation_dict3)
for vd in [variation_dict1, variation_dict2, variation_dict3]:
for k in [
'greeting', 'question', 'foo', 'foobar', 'fakebar', 'new'
]:
self.assertTrue(k in vd)
self.assertEqual(5, len(vd['greeting']))
def setUp(self) -> None:
db = Database(db_file)
db["user_name"] = None
db["question_idx"] = 0
db["answers"] = None
with open(variation_file, 'w', newline='') as f:
json.dump(variation_file_contents, f)
variety_populator_ = VarietyPopulator(variation_file)
database_populator_ = DatabasePopulator(db_file)
self._text_populator = TextPopulator(variety_populator_,
database_populator_)
self._db = db
def test_bad_database_key(self):
bad_variation_file = 'bad_variation.json'
bad_variation_file_contents = {
"greeting": ["Hi", "Hello {'db': 'not_a_key'}"]
}
db = Database(db_file)
with open(bad_variation_file, 'w', newline='') as f:
json.dump(bad_variation_file_contents, f)
variety_populator_ = VarietyPopulator(bad_variation_file)
database_populator_ = DatabasePopulator(db)
self.assertRaises(
KeyError,
TextPopulator,
variety_populator_,
database_populator_,
)
os.remove(bad_variation_file)
def test_partial_entry_in_variation_file(self):
bad_variation_file = 'bad_variation.json'
bad_variation_file_contents = {"greeting": ["Hi", "Hello{"]}
db = Database(db_file)
db["user_name"] = None
db["question_idx"] = 0
db["answers"] = None
with open(bad_variation_file, 'w', newline='') as f:
json.dump(bad_variation_file_contents, f)
variety_populator_ = VarietyPopulator(bad_variation_file)
database_populator_ = DatabasePopulator(db_file)
self.assertRaises(
ValueError,
TextPopulator,
variety_populator_,
database_populator_,
)
os.remove(bad_variation_file)
def test_replacement_with_multi_arg_entry(self):
correct_variation_file = 'correct_variation.json'
correct_variation_file_contents = {
"greeting": [
"Hi ready for number {'db': 'question_idx', 'post-op': 'increment'}",
"Hello {'db': 'user_name'}"
]
}
db = Database(db_file)
db["user_name"] = None
db["question_idx"] = 0
db["answers"] = None
with open(correct_variation_file, 'w', newline='') as f:
json.dump(correct_variation_file_contents, f)
variety_populator_ = VarietyPopulator(correct_variation_file)
database_populator_ = DatabasePopulator(db_file)
TextPopulator(
variety_populator_,
database_populator_,
)
os.remove(correct_variation_file)
],
"foo": ["foo", "fake"],
"foobar":
"foo-bar",
"fakebar":
"fake-bar"
}
with open(variation_file, 'w', newline='') as f:
json.dump(variation_dict, f)
import atexit
atexit.register(lambda: os.remove(db_file))
atexit.register(lambda: os.remove(variation_file))
variety_populator_ = VarietyPopulator(variation_file)
database_populator_ = DatabasePopulator(db_file)
text_populator = TextPopulator(variety_populator_, database_populator_)
ask_name = Node(name='ask name',
content="What's your name?",
options='Okay',
message_type='text entry',
result_db_key='user_name',
result_convert_from_str_fn=str,
tests=lambda x: len(x) > 1,
error_message='Enter something with at least two letters',
is_confirm=True,
text_populator=text_populator,
transitions='ask age')
ask_age = Node(name='ask age',
def test_exception_on_wildcard_symbols(self):
vp = VarietyPopulator(file1_path)
for tag in ['abc.', 'waoh$$', '(what)']:
self.assertRaises(ValueError, vp.get_num_variations, tag)
self.assertRaises(ValueError, vp.get_replacement, tag)