def add_default_stores(amap):
sql = SQLStorageConfiguration()
amap['sqlite'] = {
'type': 'sql',
'config': sql.create_sqlstorage_config()
}
mongo = MongoStorageConfiguration()
amap['mongo'] = {
'type': 'mongo',
'config': mongo.create_mongostorage_config()
}
redis = RedisStorageConfiguration()
amap['redis'] = {
'type': 'redis',
'config': redis.create_redisstorage_config()
}
file = FileStorageConfiguration()
amap['file'] = {
'type': 'file',
'config': file.create_filestorage_config()
}
logger = LoggerStorageConfiguration()
amap['logger'] = {
'type': 'logger',
'config': logger.create_loggerstorage_config()
}
def test_initialise_with_no_config_no_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
other:
""", ConsoleConfiguration(), ".")
logger_config = yaml.get_section("logger")
config = LoggerStorageConfiguration()
config.load_config_section(yaml, logger_config, ".")
self.assertEqual("conversation", config.conversation_logger)
def tests_conversation_storage(self):
config = LoggerStorageConfiguration()
engine = LoggerStorageEngine(config)
engine.initialise()
store = LoggerConversationStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_conversation_storage(store, can_empty=False, test_load=False)
def load_config_section(self, configuration_file, configuration, bot_root, subs: Substitutions = None):
storage = configuration_file.get_section(self._section_name, configuration)
if storage is not None:
entities = configuration_file.get_section("entities", storage)
entity_types = configuration_file.get_child_section_keys("entities", storage)
for entity in entity_types:
entity_config = configuration_file.get_section(entity, entities)
self._entity_store[entity] = entity_config
stores = configuration_file.get_section("stores", storage)
store_names = configuration_file.get_child_section_keys("stores", storage)
for store in store_names:
store_config = configuration_file.get_section(store, stores)
keys = configuration_file.get_keys(store_config)
if 'type' not in keys:
YLogger.error(None, "'type' section missing from client config stores element [%s], ignoring config", store)
continue
if 'config' not in keys:
YLogger.error(None, "'config' section missing from client config stores element [%s], ignoring config", store)
continue
type = configuration_file.get_option(store_config, 'type', subs=subs)
if type == 'sql':
config = SQLStorageConfiguration()
config.load_config_section(configuration_file, store_config, bot_root, subs=subs)
elif type == 'mongo':
config = MongoStorageConfiguration()
config.load_config_section(configuration_file, store_config, bot_root, subs=subs)
elif type == 'redis':
config = RedisStorageConfiguration()
config.load_config_section(configuration_file, store_config, bot_root, subs=subs)
elif type == 'file':
config = FileStorageConfiguration()
config.load_config_section(configuration_file, store_config, bot_root, subs=subs)
elif type == 'logger':
config = LoggerStorageConfiguration()
config.load_config_section(configuration_file, store_config, bot_root, subs=subs)
self._store_configs[store] = config
else:
YLogger.debug(self, "'storage' section missing from client config, using to defaults")
self._entity_store = {}
self.add_default_entities(self._entity_store)
self._store_configs = {}
self.add_default_stores(self._store_configs)
def test_create_loggerstorage_config(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
logger:
type: logger
config:
conversation_logger: conversations
""", ConsoleConfiguration(), ".")
logger_config = yaml.get_section("logger")
config = LoggerStorageConfiguration()
config.load_config_section(yaml, logger_config, ".")
self.assertEquals({'conversation_logger': 'conversations'},
config.create_loggerstorage_config())
def add_default_stores(store_configs,
file=True,
sqlite=False,
mongo=False,
redis=False,
logger=False):
if sqlite is True:
store_configs['sqlite'] = SQLStorageConfiguration()
if mongo is True:
store_configs['mongo'] = MongoStorageConfiguration()
if redis is True:
store_configs['redis'] = RedisStorageConfiguration()
if file is True:
store_configs['file'] = FileStorageConfiguration()
if logger is True:
store_configs['logger'] = LoggerStorageConfiguration()
def test_store_converstion_no_logger(self):
config = LoggerStorageConfiguration()
store = MockLoggerConversationStore(config)
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
store.store_conversation(client_context, conversation)
self.assertFalse(store.logged)
def test_store_conversation(self):
config = LoggerStorageConfiguration()
engine = LoggerStorageEngine(config)
engine.initialise()
store = LoggerConversationStore(engine)
client = TestClient()
client_context = client.create_client_context("user1")
conversation = Conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
store.store_conversation(client_context, conversation)
def add_default_stores_as_yaml(store_configs,
file=True,
sqlite=False,
mongo=False,
redis=False,
logger=False):
if file is True:
store_configs['file'] = {}
store_configs['file']['type'] = 'file'
store_configs['file']['config'] = {}
store = FileStorageConfiguration()
store.to_yaml(store_configs['file']['config'], defaults=True)
if sqlite is True:
store_configs['sqlite'] = {}
store_configs['sqlite']['type'] = 'sql'
store_configs['sqlite']['config'] = {}
store = SQLStorageConfiguration()
store.to_yaml(store_configs['sqlite']['config'], defaults=True)
if mongo is True:
store_configs['mongo'] = {}
store_configs['mongo']['type'] = 'mongo'
store_configs['mongo']['config'] = {}
store = MongoStorageConfiguration()
store.to_yaml(store_configs['mongo']['config'], defaults=True)
if redis is True:
store_configs['redis'] = {}
store_configs['redis']['type'] = 'redis'
store_configs['redis']['config'] = {}
store = RedisStorageConfiguration()
store.to_yaml(store_configs['redis']['config'], defaults=True)
if logger is True:
store_configs['logger'] = {}
store_configs['logger']['type'] = 'logger'
store_configs['logger']['config'] = {}
store = LoggerStorageConfiguration()
store.to_yaml(store_configs['logger']['config'], defaults=True)
def test_initial_creation(self):
config = LoggerStorageConfiguration()
self.assertIsNotNone(config)
self.assertEqual("conversation", config.conversation_logger)
def test_initialise(self):
config = LoggerStorageConfiguration()
engine = LoggerStorageEngine(config)
engine.initialise()
store = LoggerConversationStore(engine)
self.assertEqual(store.storage_engine, engine)
def test_conversations(self):
config = LoggerStorageConfiguration()
engine = LoggerStorageEngine(config)
engine.initialise()
self.conversation_asserts(storage_engine=engine, visit=False)
def test_to_yaml_no_defaults(self):
config = LoggerStorageConfiguration()
config._conversation_logger = "convologger"
data = {}
config.to_yaml(data, False)
self.assertEquals({'conversation_logger': 'convologger'}, data)
def test_to_yaml_defaults(self):
config = LoggerStorageConfiguration()
data = {}
config.to_yaml(data, True)
self.assertEquals({'conversation_logger': 'conversation'}, data)
