def test_collection_update_to_updates_file(self):
config = FileStorageConfiguration()
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_UPDATES] = storage_engine
factory._store_to_engine_map[
StorageFactory.RDF_UPDATES] = storage_engine
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._storage_factory = factory
collection.add_entity("ACCOUNT", "hasSize", "0", "BANKING", "BANIKING")
self.assertTrue(collection.has_subject('ACCOUNT'))
self.assertTrue(collection.has_predicate('ACCOUNT', 'hasSize'))
self.assertTrue(collection.has_object('ACCOUNT', 'hasSize', "0"))
collection.delete_entity("ACCOUNT", "hasSize", "0")
self.assertFalse(collection.has_subject('ACCOUNT'))
updates_store.empty()
def load_storage(self):
self._storage = StorageFactory()
if self.configuration.client_configuration.storage is not None:
self._storage.load_engines_from_config(
self.configuration.client_configuration.storage)
else:
print("No storage defined!")
def load_storage(self):
self._storage = StorageFactory()
if self.configuration.client_configuration.storage is not None:
YLogger.debug(None, "Loading Storage Factory")
self._storage.load_engines_from_config(self.configuration.client_configuration.storage)
else:
YLogger.debug(None, "No storage defined!")
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_engines_from_config_raise_exception(self):
storage_config = StorageConfiguration()
storage_config._entity_store["MOCK"] = storage_config
storage_config._store_configs["MOCK"] = MockStorageConfiguration(
"MOCK", throwexcept=True)
factory = StorageFactory()
factory.load_engines_from_config(storage_config)
self.assertFalse(factory.storage_engine_available("MOCK"))
def load_triggers(self, storage_factory: StorageFactory):
assert isinstance(storage_factory, StorageFactory)
YLogger.debug(self, "Loading Triggers")
if storage_factory.entity_storage_engine_available(StorageFactory.TRIGGERS) is True:
trigger_engine = storage_factory.entity_storage_engine(StorageFactory.TRIGGERS)
if trigger_engine:
try:
triggers_store = trigger_engine.triggers_store()
triggers_store.load_all(self)
except Exception as e:
YLogger.exception(self, "Failed to load triggers from storage", e)
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_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_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_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_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._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.assertEquals([
re.compile('(^\\.COM|\\.COM|\\.COM$)', re.IGNORECASE), ' DOT COM '
], collection.normalise(".COM"))
self.assertEquals(None, collection.normalise(".XXX"))
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_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",
fileformat="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)
self.assertTrue(collection.load(storage_factory))
self.assertEqual(collection.personalise_string(" with me "),
"with you2")
self.assertEqual(
collection.personalise_string("Hello are you with me"),
"Hello am i2 with you2")
self.assertEqual([
re.compile('(^WITH YOU | WITH YOU | WITH YOU$)', re.IGNORECASE),
' WITH ME2 '
], collection.person(" WITH YOU "))
self.assertEqual(None, collection.person(" WITH XXX "))
def test_load(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",
fileformat="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)
self.assertTrue(collection.load(storage_factory))
self.assertEqual(collection.gender(" WITH HIM "), [
re.compile('(^WITH HIM | WITH HIM | WITH HIM$)', re.IGNORECASE),
' WITH HER '
])
self.assertEqual(collection.genderise_string("This is with him "),
"This is with her")
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(None, "I was"),
"he or she was")
self.assertEqual(
collection.personalise_string(None, "hello he was over there"),
"hello I was over there")
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(" with me "),
"with you2")
self.assertEqual(
collection.personalise_string("Hello are you with me"),
"Hello am i2 with you2")
def test_reload_jp(self):
storage_factory = StorageFactory()
tokenizer = TokenizerJP()
file_store_config = FileStorageConfiguration()
file_store_config._normal_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"normal_jp.txt",
format="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)
collection.load(storage_factory)
self.assertEqual("丸1の回答",
collection.normalise_string(tokenizer, "①の回答"))
collection.reload(storage_factory)
self.assertEqual("丸1の回答",
collection.normalise_string(tokenizer, "①の回答"))
def test_reload_jp(self):
storage_factory = StorageFactory()
tokenizer = TokenizerJP()
file_store_config = FileStorageConfiguration()
file_store_config._person2_storage = FileStoreConfiguration(
file=os.path.dirname(__file__) + os.sep + "test_files" + os.sep +
"person2_jp.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(tokenizer, "私"), "彼か彼女")
self.assertEqual(collection.personalise_string(tokenizer, "彼か彼女が来た"),
"私か私が来た")
collection.reload(storage_factory)
self.assertEqual(collection.personalise_string(tokenizer, "私"), "彼か彼女")
self.assertEqual(collection.personalise_string(tokenizer, "彼か彼女が来た"),
"私か私が来た")
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",
format="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)
collection.load(storage_factory)
self.assertEqual(
collection.normalise_string(None, "keithsterling.com"),
"keithsterling dot com")
collection.reload(storage_factory)
self.assertEqual(
collection.normalise_string(None, "keithsterling.com"),
"keithsterling dot com")
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_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_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_trigger_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"
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)
client = TestClient()
client_context = client.create_client_context("testid")
triggered = mgr.trigger("SYSTEM_STARTUP")
self.assertTrue(triggered)
triggered = mgr.trigger("SYSTEM_STARTUP", additional={"key": "value"})
self.assertTrue(triggered)
triggered = mgr.trigger("CONVERSATION_START", client_context)
self.assertTrue(triggered)
triggered = mgr.trigger("OTHER_EVENT")
self.assertFalse(triggered)
triggered = mgr.trigger("OTHER_EVENT", client_context)
self.assertFalse(triggered)
triggered = mgr.trigger("OTHER_EVENT",
client_context,
additional={"key": "value"})
self.assertFalse(triggered)
def test_load_with_exception(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"
])
storage_engine = FileStorageEngine(file_store_config)
storage_factory._storage_engines[StorageFactory.MAPS] = storage_engine
storage_factory._store_to_engine_map[
StorageFactory.MAPS] = storage_engine
collection = MapCollection()
self.assertIsNotNone(collection)
self.assertTrue(collection.load(storage_factory) == 0)
def test_save_then_load_no_config(self):
config = FileStorageConfiguration()
factory = StorageFactory()
storage_engine = FileStorageEngine(config)
storage_engine.initialise()
config = BrainBinariesConfiguration()
manager = BinariesManager(config)
self.assertIsNotNone(manager)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
self.assertFalse(
manager.save_binary(factory, client_context.bot.brain.aiml_parser))
self.assertIsNone(manager.load_binary(factory))
def create_storage_factory(self, fullpath):
config = FileStorageConfiguration()
config._binaries_storage = FileStoreConfiguration(
file=fullpath,
fileformat="binary",
encoding="utf-8",
delete_on_start=False)
factory = StorageFactory()
storage_engine = FileStorageEngine(config)
factory._storage_engines[StorageFactory.BINARIES] = storage_engine
factory._store_to_engine_map[StorageFactory.BINARIES] = storage_engine
storage_engine.initialise()
return factory
def test_reload_with_exception(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.assertTrue(collection.reload(storage_factory, "TEST_SET") > 0)
def test_load_triggers_bad_triggers(self):
config = TriggerConfiguration()
config._manager = TriggerConfiguration.LOCAL_MANAGER
mgr = TriggerManager.load_trigger_manager(config)
trigger_file = os.path.dirname(__file__) + os.sep + "bad_triggers.txt"
self.assertTrue(os.path.exists(trigger_file))
config = FileStorageConfiguration()
config._triggers_storage = FileStoreConfiguration(file=trigger_file, fileformat="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)
def test_load_triggers_no_engine(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, fileformat="text", encoding="utf-8", delete_on_start=False)
engine = FileStorageEngine(config)
engine.initialise()
storage_factory = StorageFactory()
mgr.load_triggers(storage_factory)
self.assertFalse("SYSTEM_STARTUP" in mgr.triggers)
self.assertFalse("SYSTEM_SHUTDOWN" in mgr.triggers)
self.assertFalse("CONVERSATION_START" in mgr.triggers)
