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)