def test_load(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._person2_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"person2.txt",
fileformat="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.PERSON2] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.PERSON2] = storage_engine
collection = Person2Collection()
self.assertIsNotNone(collection)
self.assertTrue(collection.load(storage_factory))
self.assertEqual(collection.personalise_string("I was"),
"he or she was")
self.assertEqual(
collection.personalise_string("hello he was over there"),
"hello i was over there")
self.assertEquals([
re.compile('(^I WAS | I WAS | I WAS$)', re.IGNORECASE),
' HE OR SHE WAS '
], collection.person(" I WAS "))
self.assertEquals(None, collection.person(" I XXX "))
def test_load_jp(self):
storage_factory = StorageFactory()
tokenizer = TokenizerJP()
file_store_config = FileStorageConfiguration()
file_store_config._denormal_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"denormal_jp.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.DENORMAL] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.DENORMAL] = storage_engine
collection = DenormalCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.denormalise_string(tokenizer, "丸1の回答"),
"①の回答")
self.assertIsNone(collection.denormalise("丸"))
def test_message_ids_save_load(self):
arguments = MockArgumentParser()
client = MockTwitterBotClient(arguments)
self.assertIsNotNone(client)
self.assertTrue(client.connect())
#TODO this writes to local storage rather than /tmp
file_store_config = FileStorageConfiguration()
file_store_config._twitter_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"gender.txt",
fileformat="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
client.storage_factory._storage_engines[
StorageFactory.TWITTER] = storage_engine
client.storage_factory._store_to_engine_map[
StorageFactory.TWITTER] = storage_engine
client._store_last_message_ids('666', '667')
ids = client._get_last_message_ids()
self.assertEqual(ids[0], '666')
self.assertEqual(ids[1], '667')
def test_reload(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._gender_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"gender.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.GENDER] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.GENDER] = storage_engine
collection = GenderCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.gender("WITH HIM"), 'with her')
self.assertEqual(collection.genderise_string(None, "This is with him"),
"This is with her")
collection.reload(storage_factory)
self.assertEqual(collection.gender("WITH HIM"), 'with her')
self.assertEqual(collection.genderise_string(None, "This is with him"),
"This is with her")
def test_reload_jp(self):
storage_factory = StorageFactory()
tokenizer = TokenizerJP()
file_store_config = FileStorageConfiguration()
file_store_config._gender_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"gender_jp.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.GENDER] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.GENDER] = storage_engine
collection = GenderCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.gender("彼"), '彼女')
self.assertEqual(collection.genderise_string(tokenizer, "彼が来た"),
"彼女が来た")
collection.reload(storage_factory)
self.assertEqual(collection.gender("彼"), '彼女')
self.assertEqual(collection.genderise_string(tokenizer, "彼が来た"),
"彼女が来た")
def test_load_jp(self):
storage_factory = StorageFactory()
tokenizer = TokenizerJP()
file_store_config = FileStorageConfiguration()
file_store_config._person_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"person_jp.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.PERSON] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.PERSON] = storage_engine
collection = PersonCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.personalise_string(tokenizer, "私が正しい"),
"貴方が正しい")
self.assertEqual(collection.personalise_string(tokenizer, "あなたは変"),
"わたしは変")
def test_load(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._person_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"person.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.PERSON] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.PERSON] = storage_engine
collection = PersonCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.personalise_string(None, "with me"),
"with you2")
self.assertEqual(
collection.personalise_string(None, "Hello are you with me"),
"Hello am I2 with you2")
def test_load_from_file(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._sets_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "sets"
])
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[StorageFactory.SETS] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.SETS] = storage_engine
collection = SetCollection()
self.assertIsNotNone(collection)
self.assertTrue(collection.load(storage_factory) > 0)
self.assertIsNotNone(collection._sets)
self.assertEqual(len(collection._sets), 1)
self.assertIsNotNone(collection._stores)
self.assertEqual(len(collection._stores), 1)
self.assertTrue("TEST_SET" in collection._sets)
self.assertTrue("TEST_SET" in collection._stores)
self.assertTrue(collection.contains('TEST_SET'))
aset = collection.set('TEST_SET')
self.assertIsNotNone(aset)
values = aset['AIR']
self.assertIsNotNone(values)
self.assertTrue(['Air', 'Force', 'blue'] in values)
def test_reload(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._denormal_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"denormal.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.DENORMAL] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.DENORMAL] = storage_engine
collection = DenormalCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
collection.reload(storage_factory)
def test_load_from_test_dir_with_subdir(self):
config = FileStorageConfiguration()
config._maps_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "data" + os.sep + "maps" +
os.sep + "text"
],
extension="txt",
subdirs=True,
format="text",
encoding="utf-8",
delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileMapsStore(engine)
map_collection = MapCollection()
store.load_all(map_collection)
self.assertTrue(map_collection.contains('TESTMAP'))
the_map = map_collection.map('TESTMAP')
self.assertIsNotNone(the_map)
self.assertEqual("6", the_map['ANT'])
self.assertTrue(map_collection.contains('TESTMAP2'))
the_map = map_collection.map('TESTMAP2')
self.assertIsNotNone(the_map)
self.assertEqual("grrrrr", the_map['BEAR'])
def test_load_from_file(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._properties_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"properties.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.PROPERTIES] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.PROPERTIES] = storage_engine
collection = PropertiesCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertTrue(collection.has_property("name"))
self.assertFalse(collection.has_property("age"))
self.assertEqual("KeiffBot 1.0", collection.property("name"))
self.assertIsNone(collection.property("age"))
def test_reload_from_file(self):
config = FileStorageConfiguration()
config._rdf_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "rdfs"
])
factory = StorageFactory()
storage_engine = FileStorageEngine(config)
factory._storage_engines[StorageFactory.RDF] = storage_engine
factory._store_to_engine_map[StorageFactory.RDF] = storage_engine
storage_engine.initialise()
collection = RDFCollection()
self.assertIsNotNone(collection)
collection.load(factory)
self.assertTrue(collection.has_subject("TEST1"))
self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
"to test"))
collection.delete_entity("TEST1", "HASPURPOSE", "to test")
self.assertFalse(
collection.has_object("TEST1", "HASPURPOSE", "to test"))
collection.reload(factory, "TESTDATA")
self.assertTrue(collection.has_subject("TEST1"))
self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
"to test"))
def test_load_from_test_dir_with_subdir(self):
config = FileStorageConfiguration()
config._sets_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "data" + os.sep + "sets" +
os.sep + "text"
],
extension="txt",
subdirs=True,
format="text",
encoding="utf-8",
delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileSetsStore(engine)
set_collection = SetCollection()
store.load_all(set_collection)
self.assertTrue(set_collection.contains('TESTSET'))
values = set_collection.set_list('TESTSET')
self.assertTrue('VAL1' in values)
self.assertTrue('VAL2' in values)
self.assertTrue('VAL3' in values)
self.assertTrue('VAL4' in values)
self.assertTrue(set_collection.contains('TESTSET2'))
values = set_collection.set_list('TESTSET2')
self.assertEqual(4, len(values))
self.assertTrue('VAL5' in values)
self.assertTrue('VAL6' in values)
self.assertTrue('VAL7' in values)
self.assertTrue('VAL8' in values)
def test_apply_updates(self):
config = FileStorageConfiguration()
config._rdf_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "rdfs"
])
tmpdir = os.path.dirname(__file__) + os.sep + "rdf_updates"
config.rdf_updates_storage._dirs = [tmpdir]
config.rdf_updates_storage._has_single_file = True
factory = StorageFactory()
storage_engine = FileStorageEngine(config)
factory._storage_engines[StorageFactory.RDF] = storage_engine
factory._store_to_engine_map[StorageFactory.RDF] = storage_engine
factory._storage_engines[StorageFactory.RDF_UPDATES] = storage_engine
factory._store_to_engine_map[
StorageFactory.RDF_UPDATES] = storage_engine
storage_engine.initialise()
updates_engine = factory.entity_storage_engine(
StorageFactory.RDF_UPDATES)
updates_store = updates_engine.rdf_updates_store()
updates_store.empty()
collection = RDFCollection()
self.assertIsNotNone(collection)
collection.load(factory)
self.assertTrue(collection.has_subject("TEST1"))
self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
"to test"))
collection.apply_updates()
def test_load_triggers(self):
config = TriggerConfiguration()
config._manager = TriggerConfiguration.LOCAL_MANAGER
mgr = TriggerManager.load_trigger_manager(config)
trigger_file = os.path.dirname(__file__) + os.sep + "triggers.txt"
self.assertTrue(os.path.exists(trigger_file))
config = FileStorageConfiguration()
config._triggers_storage = FileStoreConfiguration(file=trigger_file, format="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
storage_factory = StorageFactory()
storage_factory._storage_engines[StorageFactory.TRIGGERS] = engine
storage_factory._store_to_engine_map[StorageFactory.TRIGGERS] = engine
mgr.load_triggers(storage_factory)
triggers = mgr.get_triggers("SYSTEM_STARTUP")
self.assertIsNotNone(triggers)
self.assertEquals(2, len(triggers))
triggers = mgr.get_triggers("SYSTEM_SHUTDOWN")
self.assertIsNotNone(triggers)
self.assertEquals(1, len(triggers))
triggers = mgr.get_triggers("CONVERSATION_START")
self.assertIsNotNone(triggers)
self.assertEquals(1, len(triggers))
def test_load(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._person2_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"person2.txt",
format="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.PERSON2] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.PERSON2] = storage_engine
collection = Person2Collection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertEqual(collection.personalise_string("I was"),
"he or she was")
self.assertEqual(
collection.personalise_string("hello he was over there"),
"hello i was over there")
def test_reload(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._normal_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"normal.txt",
fileformat="text",
extension="txt",
encoding="utf-8",
delete_on_start=False)
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[
StorageFactory.NORMAL] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.NORMAL] = storage_engine
collection = NormalCollection()
self.assertIsNotNone(collection)
self.assertTrue(collection.load(storage_factory))
self.assertEqual(collection.normalise_string("keithsterling.COM"),
"keithsterling dot com")
self.assertTrue(collection.reload(storage_factory))
self.assertEqual(collection.normalise_string("keithsterling.COM"),
"keithsterling dot com")
def test_load_spelling_with_exception(self):
config = FileStorageConfiguration()
config._spelling_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "spelling" + os.sep + "corpus.txt", fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileSpellingStore(engine)
spelling_checker = NorvigSpellingChecker()
self.assertFalse(store.load_spelling(spelling_checker))
def test_load_spelling(self):
config = FileStorageConfiguration()
config._spelling_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "spelling" + os.sep + "corpus.txt", fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileSpellingStore(engine)
spelling_checker = NorvigSpellingChecker()
self.assertTrue(store.load_spelling(spelling_checker))
self.assertEqual("THESE ARE SOME WORDS", spelling_checker.correct("Thise ara sime wards"))
def test_reload_from_file_jp(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._sets_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"sets_jp"
])
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[StorageFactory.SETS] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.SETS] = storage_engine
collection = SetCollection()
self.assertIsNotNone(collection)
collection.load(storage_factory)
self.assertIsNotNone(collection._sets)
self.assertEqual(len(collection._sets), 1)
self.assertIsNotNone(collection._stores)
self.assertEqual(len(collection._stores), 1)
self.assertTrue("TEST_SET" in collection._sets)
self.assertTrue("TEST_SET" in collection._stores)
self.assertTrue("TEST_SET" in collection._is_cjk)
self.assertTrue(collection.contains('TEST_SET'))
self.assertTrue(collection.is_cjk('TEST_SET'))
aset = collection.set_list('TEST_SET')
self.assertIsNotNone(aset)
values = aset['千']
self.assertIsNotNone(values)
self.assertEqual(['千葉', '千葉県', '千葉県下'], values)
collection.reload(storage_factory, "TEST_SET")
self.assertIsNotNone(collection._sets)
self.assertEqual(len(collection._sets), 1)
self.assertIsNotNone(collection._stores)
self.assertEqual(len(collection._stores), 1)
self.assertTrue("TEST_SET" in collection._sets)
self.assertTrue("TEST_SET" in collection._stores)
self.assertTrue(collection.contains('TEST_SET'))
values = aset['千']
self.assertIsNotNone(values)
self.assertEqual(['千葉', '千葉県', '千葉県下'], values)
def test_load_postprocessors(self):
config = FileStorageConfiguration()
config._postquestionprocessors_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "processors" + os.sep + "postquestionprocessors.conf", fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FilePostQuestionProcessorsStore(engine)
collection = ProcessorCollection()
store.load(collection)
self.assertEqual(0, len(collection.processors))
def test_load_from_test_dir_no_subdir(self):
config = FileStorageConfiguration()
config._rdf_storage = FileStoreConfiguration(dirs=[os.path.dirname(__file__) + os.sep + "data" + os.sep + "rdfs" + os.sep + "text"], extension="rdf", subdirs=False, format="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileRDFStore(engine)
map_collection = RDFCollection()
store.load_all(map_collection)
self.assertTrue(map_collection.contains('ACTIVITY'))
def test_reload_no_engine(self):
storage_factory = StorageFactory()
file_store_config = FileStorageConfiguration()
file_store_config._maps_storage = FileStoreConfiguration(dirs=[
os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "maps"
])
collection = MapCollection()
self.assertIsNotNone(collection)
self.assertTrue(collection.reload(storage_factory, "TEST_MAP") == 0)
def test_storage_path_multi_paths(self):
config = FileStorageConfiguration()
tmpdir = FileStorageConfiguration.get_temp_dir()
config._learnf_storage = FileStoreConfiguration(dirs=[tmpdir + os.sep + "categories/learnf", tmpdir + os.sep + "categories/learnf2"], extension="aiml",
subdirs=False, fileformat="xml", encoding="utf-8",
delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileLearnfStore(engine)
self.assertEquals('/tmp/categories/learnf', store._get_storage_path())
self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
def test_load_variables(self):
config = FileStorageConfiguration()
config._pattern_nodes_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "nodes" + os.sep + "pattern_nodes.conf", format="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FilePatternNodeStore(engine)
collection = PatternNodeFactory()
store.load(collection)
self.assertEqual(12, len(collection.nodes))
self.assertTrue(collection.exists("zeroormore"))
def test_with_files_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
brain:
files:
sets:
dirs: $BOT_ROOT/sets
extension: .txt
subdirs: false
format: text
encoding: utf-8
delete_on_start: true
""", ConsoleConfiguration(), ".")
brain_config = yaml.get_section("brain")
self.assertIsNotNone(brain_config)
files_config = yaml.get_section("files", brain_config)
self.assertIsNotNone(files_config)
sets_config = FileStoreConfiguration("sets")
sets_config.load_config_section(yaml, files_config, ".")
self.assertFalse(sets_config.has_single_file())
self.assertTrue(sets_config.has_multiple_dirs())
self.assertEqual(["./sets"], sets_config.dirs)
self.assertEqual(".txt", sets_config.extension)
self.assertFalse(sets_config.subdirs)
self.assertEqual("utf-8", sets_config.encoding)
self.assertEqual("text", sets_config.format)
self.assertTrue(sets_config.delete_on_start)
def test_to_yaml_no_defaults(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
brain:
files:
sets:
dirs: $BOT_ROOT/sets
extension: .txt
subdirs: false
format: text
encoding: utf-8
delete_on_start: true
""", ConsoleConfiguration(), ".")
brain_config = yaml.get_section("brain")
self.assertIsNotNone(brain_config)
files_config = yaml.get_section("files", brain_config)
self.assertIsNotNone(files_config)
sets_config = FileStoreConfiguration("sets")
sets_config.load_config_section(yaml, files_config, ".")
data = {}
sets_config.to_yaml(data, False)
self.assertTrue(data['delete_on_start'])
self.assertEqual(data['dirs'], ['./sets'])
self.assertEqual(data['encoding'], 'utf-8')
self.assertEqual(data['extension'], '.txt')
self.assertEqual(data['format'], 'text')
self.assertFalse(data['subdirs'])
def test_load_from_file(self):
config = FileStorageConfiguration()
config._person_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "lookups" + os.sep + "text" + os.sep + "person.txt", format="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FilePersonStore(engine)
person_collection = PersonCollection()
store.load(person_collection)
self.assertEqual(person_collection.person(" WITH YOU "), [re.compile('(^WITH YOU | WITH YOU | WITH YOU$)', re.IGNORECASE), ' WITH ME2 '])
self.assertEqual(person_collection.personalise_string("Is he with you"), "Is he with me2")
def test_load_from_file(self):
config = FileStorageConfiguration()
config._person2_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "lookups" + os.sep + "text" + os.sep + "person2.txt", fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FilePerson2Store(engine)
person2_collection = PersonCollection()
store.load(person2_collection)
self.assertEqual(person2_collection.person(" I WAS "), [re.compile('(^I WAS | I WAS | I WAS$)', re.IGNORECASE), ' HE OR SHE WAS '])
self.assertEqual(person2_collection.personalise_string("I was there"), "he or she was there")
def test_load_from_file(self):
config = FileStorageConfiguration()
config._gender_storage = FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "lookups" + os.sep + "text" + os.sep + "gender.txt", fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
store = FileGenderStore(engine)
gender_collection = GenderCollection()
store.load(gender_collection)
self.assertEqual(gender_collection.gender(" WITH HIM "), [re.compile('(^WITH HIM | WITH HIM | WITH HIM$)', re.IGNORECASE), ' WITH HER '])
self.assertEqual(gender_collection.genderise_string("This is with him "), "This is with her")