def test_to_yaml_no_defaults_empty(self):
storage_config = StorageConfiguration()
data = {}
storage_config.to_yaml(data, defaults=False)
self.assertEquals({'entities': {}, 'stores': {}}, data)
def test_to_yaml_defaults(self):
storage_config = StorageConfiguration()
data = {}
storage_config.to_yaml(data, defaults=True)
self.assertDefaultEntities(data['entities'])
self.assertDefaultFileStoreConfig(data['stores'])
def __init__(self, name):
BaseContainerConfigurationData.__init__(self, name)
self._description = 'ProgramY AIML2.0 Client'
self._bot_configs = []
self._bot_configs.append(BotConfiguration("bot"))
self._bot_selector = None
self._scheduler = SchedulerConfiguration()
self._storage = StorageConfiguration()
self._renderer = None
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 test_create_storage_config_file_only(self):
storage_config = StorageConfiguration()
config = storage_config.create_storage_config()
self.assertIsNotNone(config)
self.assertTrue('file' in config['stores'])
self.assertFalse('sqlite' in config['stores'])
self.assertFalse('mongo' in config['stores'])
self.assertFalse('redis' in config['stores'])
self.assertFalse('logger' in config['stores'])
def test_to_yaml_no_defaults_not_empty(self):
storage_config = StorageConfiguration()
StorageConfiguration.add_default_entities(storage_config._entity_store)
StorageConfiguration.add_default_stores_as_yaml(
storage_config._store_configs)
data = {}
storage_config.to_yaml(data, defaults=False)
self.assertDefaultEntities(data['entities'])
self.assertDefaultFileStoreConfig(data['stores'])
def __init__(self, name):
BaseContainerConfigurationData.__init__(self, name)
self._description = 'ProgramY AIML2.0 Client'
self._renderer = self._get_renderer_class()
self._scheduler = SchedulerConfiguration()
self._storage = StorageConfiguration()
self._email = EmailConfiguration()
self._triggers = TriggerConfiguration()
self._responder = PingResponderConfig()
self._bot_selector = self._get_bot_selector_class()
bot_config = BotConfiguration('bot')
self._bot_configs = [bot_config]
def test_create_storage_config_all(self):
storage_config = StorageConfiguration()
config = storage_config.create_storage_config(file=True,
sqlite=True,
mongo=True,
redis=True,
logger=True)
self.assertIsNotNone(config)
self.assertTrue('file' in config['stores'])
self.assertTrue('sqlite' in config['stores'])
self.assertTrue('mongo' in config['stores'])
self.assertTrue('redis' in config['stores'])
self.assertTrue('logger' in config['stores'])
def test_create_storage_config_nothing(self):
storage_config = StorageConfiguration()
config = storage_config.create_storage_config(file=False,
sqlite=False,
mongo=False,
redis=False,
logger=False)
self.assertIsNotNone(config)
self.assertFalse('file' in config['stores'])
self.assertFalse('sqlite' in config['stores'])
self.assertFalse('mongo' in config['stores'])
self.assertFalse('redis' in config['stores'])
self.assertFalse('logger' in config['stores'])
def test_with_no_data_no_config(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
console:
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
self.assertIsNotNone(storage_config.entity_store)
self.assert_entity_store(storage_config)
self.assertIsNotNone(storage_config.storage_configurations)
self.assert_storage_configurations(storage_config)
def test_with_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
console:
storage:
entities:
users: sqlite
linked_accounts: sqlite
links: sqlite
categories: file
errors: file
duplicates: file
learnf: file
conversations: file
maps: file
sets: file
rdf: file
denormal: file
normal: file
gender: file
person: file
person2: file
regex_templates: file
properties: file
variables: file
defaults: file
twitter: file
spelling_corpus: file
license_keys: file
template_nodes: file
pattern_nodes: file
binaries: file
braintree: file
preprocessors: file
postprocessors: file
usergroups: file
triggers: file
stores:
sqlite:
type: sql
config:
url: sqlite:///:memory
echo: false
encoding: utf-8
create_db: true
drop_all_first: true
mongo:
type: mongo
config:
url: mongodb://localhost:27017/
database: programy
drop_all_first: true
redis:
type: redis
config:
host: localhost
port: 6379
password: None
db: 0
prefix: programy
drop_all_first: True
file:
type: file
config:
properties_storage:
file: ./storage/properties
conversations_storage:
dir: ./storage/conversations
logger:
type: logger
config:
conversation_logger: conversation
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
self.assertIsNotNone(storage_config.entity_store)
self.assert_entity_store(storage_config)
self.assertIsNotNone(storage_config.storage_configurations)
self.assert_storage_configurations(storage_config)
def test_defaults(self):
storage_config = StorageConfiguration()
data = {}
storage_config.to_yaml(data, True)
StorageConfigurationTests.assert_defaults(self, data)
def test_initialise_with_config_file_only(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
console:
storage:
entities:
users: file
linked_accounts: file
links: file
properties: file
conversations: file
categories: file
stores:
file:
type: file
config:
storage_dir: ./storage
properties_storage: ./storage/properties
conversations_storage: ./storage/conversations
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
factory = StorageFactory()
factory.load_engines_from_config(storage_config)
self.assertFalse(factory.storage_engine_available("sql"))
self.assertFalse(factory.storage_engine_available("mongo"))
self.assertFalse(factory.storage_engine_available("redis"))
self.assertFalse(factory.storage_engine_available("logger"))
self.assertTrue(factory.storage_engine_available("file"))
self.assertTrue(factory.entity_storage_engine_available("users"))
self.assertIsInstance(factory.entity_storage_engine("users"),
FileStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("linked_accounts"))
self.assertIsInstance(factory.entity_storage_engine("linked_accounts"),
FileStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("links"))
self.assertIsInstance(factory.entity_storage_engine("links"),
FileStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("properties"))
self.assertIsInstance(factory.entity_storage_engine("properties"),
FileStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("conversations"))
self.assertIsInstance(factory.entity_storage_engine("conversations"),
FileStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("categories"))
self.assertIsInstance(factory.entity_storage_engine("categories"),
FileStorageEngine)
self.assertFalse(factory.entity_storage_engine_available("other"))
self.assertIsNone(factory.entity_storage_engine("other"))
def test_initialise_with_config_mixed(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
console:
storage:
entities:
users: sql
linked_accounts: sql
links: sql
properties: redis
conversations: mongo
categories: sql
stores:
sql:
type: sql
config:
url: sqlite:///:memory
echo: false
encoding: utf-8
create_db: true
drop_all_first: true
mongo:
type: mongo
config:
url: mongodb://localhost:27017/
database: programy
drop_all_first: true
redis:
type: redis
config:
host: localhost
port: 6379
password: null
db: 0
prefix: programy
drop_all_first: True
file:
type: file
config:
storage_dir: ./storage
properties_storage: ./storage/properties
conversations_storage: ./storage/conversations
logger:
type: logger
config:
conversation_logger: conversation
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
factory = StorageFactory()
factory.load_engines_from_config(storage_config)
self.assertTrue(factory.storage_engine_available("sql"))
self.assertIsInstance(factory.storage_engine("sql"),
MongoStorageEngine)
self.assertTrue(factory.storage_engine_available("mongo"))
self.assertIsInstance(factory.storage_engine("mongo"),
MongoStorageEngine)
self.assertTrue(factory.storage_engine_available("redis"))
self.assertIsInstance(factory.storage_engine("redis"),
RedisStorageEngine)
self.assertTrue(factory.storage_engine_available("file"))
self.assertIsInstance(factory.storage_engine("file"),
FileStorageEngine)
self.assertTrue(factory.storage_engine_available("logger"))
self.assertIsInstance(factory.storage_engine("logger"),
LoggerStorageEngine)
self.assertFalse(factory.storage_engine_available("other"))
self.assertIsNone(factory.storage_engine("other"))
self.assertTrue(factory.entity_storage_engine_available("users"))
self.assertIsInstance(factory.entity_storage_engine("users"),
SQLStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("linked_accounts"))
self.assertIsInstance(factory.entity_storage_engine("linked_accounts"),
SQLStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("links"))
self.assertIsInstance(factory.entity_storage_engine("links"),
SQLStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("properties"))
self.assertIsInstance(factory.entity_storage_engine("properties"),
RedisStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("conversations"))
self.assertIsInstance(factory.entity_storage_engine("conversations"),
MongoStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("categories"))
self.assertIsInstance(factory.entity_storage_engine("categories"),
SQLStorageEngine)
self.assertFalse(factory.entity_storage_engine_available("other"))
self.assertIsNone(factory.entity_storage_engine("other"))
def test_initialise_with_config_mongo(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
console:
storage:
entities:
users: mongo
linked_accounts: mongo
links: mongo
properties: mongo
conversations: mongo
categories: mongo
stores:
mongo:
type: mongo
config:
url: mongodb://localhost:27017/
database: programy
drop_all_first: true
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
factory = StorageFactory()
factory.load_engines_from_config(storage_config)
self.assertTrue(factory.storage_engine_available("mongo"))
self.assertFalse(factory.storage_engine_available("sql"))
self.assertFalse(factory.storage_engine_available("redis"))
self.assertFalse(factory.storage_engine_available("file"))
self.assertFalse(factory.storage_engine_available("logger"))
self.assertFalse(factory.storage_engine_available("other"))
self.assertIsNone(factory.storage_engine("other"))
self.assertTrue(factory.entity_storage_engine_available("users"))
self.assertIsInstance(factory.entity_storage_engine("users"),
MongoStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("linked_accounts"))
self.assertIsInstance(factory.entity_storage_engine("linked_accounts"),
MongoStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("links"))
self.assertIsInstance(factory.entity_storage_engine("links"),
MongoStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("properties"))
self.assertIsInstance(factory.entity_storage_engine("properties"),
MongoStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("conversations"))
self.assertIsInstance(factory.entity_storage_engine("conversations"),
MongoStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("categories"))
self.assertIsInstance(factory.entity_storage_engine("categories"),
MongoStorageEngine)
self.assertFalse(factory.entity_storage_engine_available("other"))
self.assertIsNone(factory.entity_storage_engine("other"))
def test_initialise_with_config_sql_only(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
console:
storage:
entities:
users: sql
linked_accounts: sql
links: sql
properties: sql
conversations: sql
categories: sql
stores:
sql:
type: sql
config:
url: sqlite:///:memory
echo: false
encoding: utf-8
create_db: true
drop_all_first: true
""", ConsoleConfiguration(), ".")
bot_config = yaml.get_section("console")
storage_config = StorageConfiguration()
storage_config.load_config_section(yaml, bot_config, ".")
factory = StorageFactory()
factory.load_engines_from_config(storage_config)
self.assertTrue(factory.storage_engine_available("sql"))
self.assertFalse(factory.storage_engine_available("mongo"))
self.assertFalse(factory.storage_engine_available("redis"))
self.assertFalse(factory.storage_engine_available("file"))
self.assertFalse(factory.storage_engine_available("logger"))
self.assertFalse(factory.storage_engine_available("other"))
self.assertIsNone(factory.storage_engine("other"))
self.assertTrue(factory.entity_storage_engine_available("users"))
self.assertIsInstance(factory.entity_storage_engine("users"),
SQLStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("linked_accounts"))
self.assertIsInstance(factory.entity_storage_engine("linked_accounts"),
SQLStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("links"))
self.assertIsInstance(factory.entity_storage_engine("links"),
SQLStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("properties"))
self.assertIsInstance(factory.entity_storage_engine("properties"),
SQLStorageEngine)
self.assertTrue(
factory.entity_storage_engine_available("conversations"))
self.assertIsInstance(factory.entity_storage_engine("conversations"),
SQLStorageEngine)
self.assertTrue(factory.entity_storage_engine_available("categories"))
self.assertIsInstance(factory.entity_storage_engine("categories"),
SQLStorageEngine)
self.assertFalse(factory.entity_storage_engine_available("other"))
self.assertIsNone(factory.entity_storage_engine("other"))