def test_load_save_binaries(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_secure_brain.yaml",
"test_secure_brain.windows.yaml")
brains_section = yaml.get_section("brains")
brain_section = yaml.get_section("brain", brains_section)
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, brain_section, ".")
brain_config.binaries._save_binary = True
brain_config.binaries._load_binary = False
client = TestClient()
client_context = client.create_client_context("testid")
brain1 = Brain(client_context.bot, brain_config)
self.assertIsNotNone(brain1)
brain_config.binaries._save_binary = False
brain_config.binaries._load_binary = True
brain2 = Brain(client_context.bot, brain_config)
self.assertIsNotNone(brain2)
def load_configurations(self,
configuration_file,
bot,
bot_root,
subs: Substitutions = None):
if bot is not None:
brain_names = configuration_file.get_multi_option(
bot, "brain", missing_value="brain")
first = True
for name in brain_names:
if first is True:
config = self._brain_configs[0]
first = False
else:
config = BrainConfiguration(name)
self._brain_configs.append(config)
config.load_configuration(configuration_file,
bot_root,
subs=subs)
self._brain_selector = configuration_file.get_option(
bot, "brain_selector", subs=subs)
else:
YLogger.warning(
self,
"No brain name defined for bot [%s], defaulting to 'brain'.",
self.section_name)
brain_name = "brain"
self._brain_configs[0]._section_name = brain_name
self._brain_configs[0].load_configuration(configuration_file,
bot_root,
subs=subs)
def test_brain_init_with_secure_config(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_secure_brain.yaml",
"test_secure_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, os.path.dirname(__file__))
brain = Brain(None, brain_config)
self.assertIsNotNone(brain)
self.assertIsNotNone(brain.aiml_parser)
self.assertIsNotNone(brain.denormals)
self.assertIsNotNone(brain.normals)
self.assertIsNotNone(brain.genders)
self.assertIsNotNone(brain.persons)
self.assertIsNotNone(brain.person2s)
self.assertIsNotNone(brain.properties)
self.assertIsNotNone(brain.rdf)
self.assertIsNotNone(brain.sets)
self.assertIsNotNone(brain.maps)
self.assertIsNotNone(brain.preprocessors)
self.assertIsNotNone(brain.postprocessors)
self.assertIsNotNone(brain.authentication)
self.assertIsNotNone(brain.authorisation)
self.assertIsNone(brain.default_oob)
self.assertEquals({}, brain.oobs)
def test_brain_init_with_secure_config(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_secure_brain.yaml", "test_secure_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, os.path.dirname(__file__))
client = TestClient()
client_context = client.create_client_context("testid")
brain = Brain(client_context.bot, brain_config)
self.assertIsNotNone(brain)
self.assertIsNotNone(brain.aiml_parser)
self.assertIsNotNone(brain.denormals)
self.assertIsNotNone(brain.normals)
self.assertIsNotNone(brain.genders)
self.assertIsNotNone(brain.persons)
self.assertIsNotNone(brain.person2s)
self.assertIsNotNone(brain.properties)
self.assertIsNotNone(brain.rdf)
self.assertIsNotNone(brain.sets)
self.assertIsNotNone(brain.maps)
self.assertIsNotNone(brain.preprocessors)
self.assertIsNotNone(brain.postprocessors)
self.assertIsNotNone(brain.security)
def test_selection_multi_brain(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
brain1 = Brain(bot, BrainConfiguration())
brain2 = Brain(bot, BrainConfiguration())
brain3 = Brain(bot, BrainConfiguration())
brains = {"brain1": brain1, "brain2": brain2, "brain3": brain3}
config = ClientConfigurationData(name="test")
selector = DefaultBrainSelector(config, brains)
selected = selector.select_brain()
self.assertIsNotNone(selected)
self.assertEqual(selected, brain1)
selected = selector.select_brain()
self.assertIsNotNone(selected)
self.assertEqual(selected, brain2)
selected = selector.select_brain()
self.assertIsNotNone(selected)
self.assertEqual(selected, brain3)
selected = selector.select_brain()
self.assertIsNotNone(selected)
self.assertEqual(selected, brain1)
def test_format_message_with_client_and_bot_and_brain(self):
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(None, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[] [] [testbrain] - Test Message", msg)
def test_format_message_with_client_and_bot_and_brain(self):
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(None, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[] [] [testbrain] - Test Message", msg)
def test_with_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text(
"""
brain:
# Overrides
overrides:
allow_system_aiml: true
allow_learn_aiml: true
allow_learnf_aiml: true
# Defaults
defaults:
default_get: unknown
default_property: unknown
default_map: unknown
learnf_path: file
# Binary
binaries:
save_binary: true
load_binary: true
load_aiml_on_binary_fail: true
# Braintree
braintree:
create: true
security:
authentication:
classname: programy.security.authenticate.passthrough.BasicPassThroughAuthenticationService
denied_srai: AUTHENTICATION_FAILED
authorisation:
classname: programy.security.authorise.usergroupsauthorisor.BasicUserGroupAuthorisationService
denied_srai: AUTHORISATION_FAILED
usergroups:
storage: file
dynamic:
variables:
gettime: programy.dynamic.variables.datetime.GetTime
sets:
numeric: programy.dynamic.sets.numeric.IsNumeric
roman: programy.dynamic.sets.roman.IsRomanNumeral
maps:
romantodec: programy.dynamic.maps.roman.MapRomanToDecimal
dectoroman: programy.dynamic.maps.roman.MapDecimalToRoman
""", ConsoleConfiguration(), ".")
brain_section = yaml.get_section("brain")
brain_configuration = BrainConfiguration()
brain_configuration.load_configuration(yaml, brain_section, ".")
BrainConfigurationTests.assert_brain_config(self, brain_configuration)
def test_format_message_with_client_and_default_bot_and_brain(self):
brain_config = BrainConfiguration()
client = TestClient()
context = client.create_client_context("testid")
brain_config._section_name = "testbrain"
brain = Brain(context.bot, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEqual("[testclient] [bot] [testbrain] - Test Message", msg)
def test_brain_init_with_secure_config(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_secure_brain.yaml",
"test_secure_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, os.path.dirname(__file__))
brain = Brain(None, brain_config)
self.assertIsNotNone(brain)
def test_oob_processing(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
brain = Brain(None, brain_config)
self.assertEqual("", brain.process_oob("console", "<oob></oob>"))
def test_load_tokenizer_no_class(self):
config = BrainConfiguration()
self.assertIsNotNone(config)
tokenizer_config = BrainTokenizerConfiguration()
self.assertIsNotNone(tokenizer_config)
tokenizer_config._classname = None
tokenizer_config._punctation_chars = ''
config._tokenizer = tokenizer_config
tokenizer = Tokenizer.load_tokenizer(config)
self.assertIsNotNone(tokenizer)
self.assertIsInstance(tokenizer, Tokenizer)
def test_load_tokenizer(self):
config = BrainConfiguration()
self.assertIsNotNone(config)
tokenizer_config = BrainTokenizerConfiguration()
self.assertIsNotNone(tokenizer_config)
tokenizer_config._classname = 'programy.dialog.tokenizer.tokenizer.Tokenizer'
tokenizer_config._punctation_chars = ''
config._tokenizer = tokenizer_config
tokenizer = Tokenizer.load_tokenizer(config)
self.assertIsNotNone(tokenizer)
self.assertIsInstance(tokenizer, Tokenizer)
def test_format_message_with_client_and_bot_and_brain(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] [testbrain] - Test Message", msg)
def test_format_message_with_client_and_bot_and_brain(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
msg = YLogger.format_message(brain, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] [testbrain] - Test Message", msg)
def test_oob_loading(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
brain = Brain(None, brain_config)
self.assertIsInstance(brain.default_oob, DefaultOutOfBandProcessor)
self.assertIsInstance(brain.oobs['dial'], DialOutOfBandProcessor)
self.assertIsInstance(brain.oobs['email'], EmailOutOfBandProcessor)
def test_oob_loading(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml", "test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
client = TestClient()
client_context = client.create_client_context("testid")
brain = Brain(client_context.bot, brain_config)
self.assertIsInstance(brain._oobhandler.default_oob, DefaultOutOfBandProcessor)
self.assertIsInstance(brain._oobhandler.oobs['dial'], DialOutOfBandProcessor)
self.assertIsInstance(brain._oobhandler.oobs['email'], EmailOutOfBandProcessor)
def test_call_GeneralRest(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
node._method = TemplateWordNode("POST")
node._query = TemplateWordNode('"userid":"1234567890"')
node._header = TemplateWordNode('"Content-Type":"application/json"')
node._body = TemplateWordNode("Hello")
root.append(node)
self.assertEqual("asked", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("asked", node.resolve(self._client_context))
self.assertEqual("asked", question.property('__SUBAGENT_BODY__'))
def test_reload_unknowns(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
client = TestClient()
client_context = client.create_client_context("testid")
brain = Brain(client_context.bot, brain_config)
brain.reload_map("Unknown")
brain.reload_set("Unknown")
brain.reload_rdf("Unknown")
def __init__(self, section_name="bot"):
self._brain_configs = []
self._brain_configs.append(BrainConfiguration("brain"))
self._brain_selector = None
self._bot_root = BotConfiguration.DEFAULT_ROOT
self._default_response = BotConfiguration.DEFAULT_RESPONSE
self._default_response_srai = BotConfiguration.DEFAULT_RESPONSE_SRAI
self._exit_response = BotConfiguration.DEFAULT_EXIT_RESPONSE
self._exit_response_srai = BotConfiguration.DEFAULT_EXIT_RESPONSE_SRAI
self._initial_question = BotConfiguration.DEFAULT_INITIAL_QUESTION
self._initial_question_srai = BotConfiguration.DEFAULT_INITIAL_QUESTION_SRAI
self._empty_string = BotConfiguration.DEFAULT_EMPTY_STRING
self._override_properties = BotConfiguration.DEFAULT_OVERRIDE_PREDICATES
self._max_question_recursion = BotConfiguration.DEFAULT_MAX_QUESTION_RECURSION
self._max_question_timeout = BotConfiguration.DEFAULT_MAX_QUESTION_TIMEOUT
self._max_search_depth = BotConfiguration.DEFAULT_MAX_SEARCH_DEPTH
self._max_search_timeout = BotConfiguration.DEFAULT_MAX_SEARCH_TIMEOUT
self._tab_parse_output = BotConfiguration.DEFAULT_TAB_PARSE_OUTPUT
self._spelling = BotSpellingConfiguration()
self._from_translator = BotTranslatorConfiguration(
name="from_translator")
self._to_translator = BotTranslatorConfiguration(name="to_translator")
self._sentiment = BotSentimentAnalyserConfiguration()
self._conversations = BotConversationsConfiguration()
self._splitter = BotSentenceSplitterConfiguration()
self._joiner = BotSentenceJoinerConfiguration()
BaseContainerConfigurationData.__init__(self, section_name)
def test_call_GeneralRest_response_empty(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDREST__")
service.set_response("")
self.assertEqual("", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("", node.resolve(self._client_context))
def _load_bot_configurations(self, configuration_file, section, bot_root,
subs):
bots = configuration_file.get_section("bots", section)
if bots is not None:
bot_keys = configuration_file.get_keys(bots)
first = True
for name in bot_keys:
if first is True:
self._bot_configs.clear()
first = False
bot_config = configuration_file.get_section(name, bots)
config = BotConfiguration(name)
config.load_configuration_section(configuration_file,
bot_config,
bot_root,
subs=subs)
self._bot_configs.append(config)
if len(self._bot_configs) == 0:
YLogger.warning(
self,
"No bot name defined for client [%s], defaulting to 'bot'.",
self.section_name)
self._bot_configs.append(BotConfiguration("bot"))
self._bot_configs[0].configurations.append(
BrainConfiguration("brain"))
self._bot_selector = configuration_file.get_option(
section,
"bot_selector",
missing_value="programy.clients.botfactory.DefaultBotSelector",
subs=subs)
def test_call_PublishedBot_response_default(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._userId = TemplateWordNode('1234567890')
node._default = "unknown"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response("")
self.set_collection_botnames()
self.assertEqual("unknown", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("unknown", node.resolve(self._client_context))
self.assertEqual("unknown",
question.property('__SUBAGENT_EXTBOT__.testbot'))
def test_call_CustomService_response_default(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._service = "mock"
node._default = "unknown"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("mock")
service.set_response("")
self.assertEqual("unknown", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("unknown", node.resolve(self._client_context))
self.assertEqual("unknown", question.property('__SUBAGENT__.mock'))
def get_brain_config(self):
brain_config = BrainConfiguration()
brain_config.security._authorisation = BrainSecurityConfiguration(
"authorisation")
brain_config.security.authorisation._classname = "programy.security.authorise.usergroupsauthorisor.BasicUserGroupAuthorisationService"
brain_config.security.authorisation._denied_srai = "ACCESS_DENIED"
brain_config.security.authorisation._usergroups = "$BOT_ROOT/usergroups.yaml"
return brain_config
def test_brain_init_with_config(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
brain = Brain(None, brain_config)
self.assertIsNotNone(brain)
self.assertIsNotNone(brain.aiml_parser)
self.assertIsNotNone(brain.denormals)
self.assertIsNotNone(brain.normals)
self.assertIsNotNone(brain.genders)
self.assertIsNotNone(brain.persons)
self.assertIsNotNone(brain.person2s)
self.assertIsNotNone(brain.properties)
self.assertIsNotNone(brain.rdf)
self.assertIsNotNone(brain.sets)
self.assertIsNotNone(brain.maps)
self.assertIsNotNone(brain.preprocessors)
self.assertIsNotNone(brain.postprocessors)
self.assertIsNotNone(brain.authentication)
self.assertIsNotNone(brain.authorisation)
self.assertIsNotNone(brain.default_oob)
self.assertIsNotNone(brain.oobs)
if os.path.exists(brain_config.binaries.binary_filename):
os.remove(brain_config.binaries.binary_filename)
self.assertFalse(os.path.exists(brain_config.binaries.binary_filename))
brain.save_binary(brain_config)
self.assertTrue(os.path.exists(brain_config.binaries.binary_filename))
brain.load_binary(brain_config)
oob_content = ET.fromstring("<oob><something>other</something></oob>")
self.assertEqual(
"",
brain.default_oob.process_out_of_bounds(self._client_context,
oob_content))
oob_content = ET.fromstring("<oob><dial>07777777777</dial></oob>")
self.assertEqual(
"",
brain.oobs['dial'].process_out_of_bounds(self._client_context,
oob_content))
def test_with_no_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
brain:
""", ConsoleConfiguration(), ".")
brain_config = yaml.get_section("brain")
brain_configuration = BrainConfiguration()
brain_configuration.load_configuration(yaml, brain_config, ".")
self.assertFalse(brain_configuration.overrides.allow_system_aiml)
self.assertFalse(brain_configuration.overrides.allow_learn_aiml)
self.assertFalse(brain_configuration.overrides.allow_learnf_aiml)
self.assertIsNotNone(brain_configuration.defaults)
self.assertEqual(brain_configuration.defaults.default_get, "unknown")
self.assertEqual(brain_configuration.defaults.default_property,
"unknown")
self.assertEqual(brain_configuration.defaults.default_map, "unknown")
self.assertIsNotNone(brain_configuration.binaries)
self.assertFalse(brain_configuration.binaries.save_binary)
self.assertFalse(brain_configuration.binaries.load_binary)
self.assertFalse(brain_configuration.binaries.load_aiml_on_binary_fail)
self.assertIsNotNone(brain_configuration.braintree)
self.assertFalse(brain_configuration.braintree.create)
self.assertIsNotNone(brain_configuration.services)
self.assertFalse(brain_configuration.services.exists('OPENCHAT'))
self.assertFalse(brain_configuration.services.exists('REST'))
self.assertIsNotNone(brain_configuration.security)
self.assertIsNone(brain_configuration.security.authorisation)
self.assertIsNone(brain_configuration.security.authentication)
self.assertIsNotNone(brain_configuration.dynamics)
self.assertIsNotNone(brain_configuration.dynamics.dynamic_sets)
self.assertIsNotNone(brain_configuration.dynamics.dynamic_maps)
self.assertIsNotNone(brain_configuration.dynamics.dynamic_vars)
def test_format_message_with_client_context(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
client_context = ClientContext(client, "testuser")
client_context._bot = bot
client_context._brain = brain
msg = YLogger.format_message(client_context, "Test Message")
self.assertIsNotNone(msg)
self.assertEqual("[testclient] [testbot] [testbrain] [testuser] - Test Message", msg)
def test_post_process_question_with_processing(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brains_section = yaml.get_section("brains")
brain_section = yaml.get_section("brain", brains_section)
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, brain_section, ".")
client = TestClient()
client_context = client.create_client_context("testid")
brain = Brain(client_context.bot, brain_config)
self.assertIsNotNone(brain)
response = brain.post_process_question(client_context, "Hello")
self.assertEquals("Other", response)
def test_format_message_with_client_context(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
client_context = ClientContext(client, "testuser")
client_context._bot = bot
client_context._brain = brain
msg = YLogger.format_message(client_context, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals("[testclient] [testbot] [testbrain] [testuser] - Test Message", msg)
def load_configurations(self, configuration_file, bot, bot_root):
if bot is not None:
brain_names = configuration_file.get_multi_option(bot, "brain", missing_value="brain")
first = True
for name in brain_names:
if first is True:
config = self._brain_configs[0]
first = False
else:
config = BrainConfiguration(name)
self._brain_configs.append(config)
config.load_configuration(configuration_file, bot_root)
self._brain_selector = configuration_file.get_option(bot, "brain_selector")
else:
YLogger.warning(self, "No brain name defined for bot [%s], defaulting to 'brain'.", self.section_name)
brain_name = "brain"
self._brain_configs[0]._section_name = brain_name
self._brain_configs[0].load_configuration(configuration_file, bot_root)
def test_load_services(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
self.assertIsNotNone(ServiceFactory.get_service("mock"))
self.assertIsInstance(ServiceFactory.get_service("mock"), MockService)
def test_call_GeneralRest_only_host(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
self.assertEqual("asked", node.resolve(self._client_context))
def test_oob_stripping(self):
yaml = YamlConfigurationFile()
self.load_os_specific_configuration(yaml, "test_brain.yaml",
"test_brain.windows.yaml")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
brain = Brain(None, brain_config)
response, oob = brain.strip_oob("<oob>command</oob>")
self.assertEqual("", response)
self.assertEqual("<oob>command</oob>", oob)
response, oob = brain.strip_oob("This <oob>command</oob>")
self.assertEqual("This ", response)
self.assertEqual("<oob>command</oob>", oob)
response, oob = brain.strip_oob("This <oob>command</oob> That")
self.assertEqual("This That", response)
self.assertEqual("<oob>command</oob>", oob)
def test_with_data(self):
yaml = YamlConfigurationFile()
self.assertIsNotNone(yaml)
yaml.load_from_text("""
brain:
overrides:
allow_system_aiml: true
allow_learn_aiml: true
allow_learnf_aiml: true
defaults:
default-get: unknown
default-property: unknown
default-map: unknown
learnf-path: /tmp/learnf
nodes:
pattern_nodes: $BOT_ROOT/config/pattern_nodes.conf
template_nodes: $BOT_ROOT/config/template_nodes.conf
binaries:
save_binary: false
load_binary: false
binary_filename: /tmp/y-bot.brain
load_aiml_on_binary_fail: false
braintree:
file: /tmp/braintree.xml
content: xml
files:
aiml:
files: $BOT_ROOT/aiml
extension: .aiml
directories: true
errors: /tmp/y-bot_errors.txt
duplicates: /tmp/y-bot_duplicates.txt
conversation: /tmp/y-bot_conversation.txt
sets:
files: $BOT_ROOT/sets
extension: .txt
directories: false
maps:
files: $BOT_ROOT/maps
extension: .txt
directories: false
denormal: $BOT_ROOT/config/denormal.txt
normal: $BOT_ROOT/config/normal.txt
gender: $BOT_ROOT/config/gender.txt
person: $BOT_ROOT/config/person.txt
person2: $BOT_ROOT/config/person2.txt
properties: $BOT_ROOT/config/properties.txt
triples: $BOT_ROOT/config/triples.txt
preprocessors: $BOT_ROOT/config/preprocessors.conf
postprocessors: $BOT_ROOT/config/postprocessors.conf
regex_templates: $BOT_ROOT/config/regex-templates.txt
security:
authentication:
classname: programy.security.authenticate.passthrough.PassThroughAuthenticationService
denied_srai: AUTHENTICATION_FAILED
authorisation:
classname: programy.security.authorise.passthrough.PassThroughAuthorisationService
denied_srai: AUTHORISATION_FAILED
oob:
default:
classname: programy.oob.default.DefaultOutOfBandProcessor
dial:
classname: programy.oob.dial.DialOutOfBandProcessor
email:
classname: programy.oob.email.EmailOutOfBandProcessor
dynamic:
variables:
gettime: programy.dynamic.variables.datetime.GetTime
sets:
number: programy.dynamic.sets.numeric.IsNumeric
roman: programy.dynamic.sets.roman.IsRomanNumeral
maps:
romantodec: programy.dynamic.maps.roman.MapRomanToDecimal
dectoroman: programy.dynamic.maps.roman.MapDecimalToRoman
services:
REST:
classname: programy.services.rest.GenericRESTService
method: GET
host: 0.0.0.0
Pannous:
classname: programy.services.pannous.PannousService
url: http://weannie.pannous.com/api
Pandora:
classname: programy.services.pandora.PandoraService
url: http://www.pandorabots.com/pandora/talk-xml
Wikipedia:
classname: programy.services.wikipediaservice.WikipediaService
""", ConsoleConfiguration(), ".")
brain_config = BrainConfiguration()
brain_config.load_configuration(yaml, ".")
self.assertIsNotNone(brain_config.overrides)
self.assertTrue(brain_config.overrides.allow_system_aiml)
self.assertTrue(brain_config.overrides.allow_learn_aiml)
self.assertTrue(brain_config.overrides.allow_learnf_aiml)
self.assertIsNotNone(brain_config.defaults)
self.assertEqual("unknown", brain_config.defaults.default_get)
self.assertEqual("unknown", brain_config.defaults.default_property)
self.assertEqual("unknown", brain_config.defaults.default_map)
self.assertEqual("/tmp/learnf", brain_config.defaults.learnf_path)
self.assertIsNotNone(brain_config.nodes)
self.assertEquals("./config/pattern_nodes.conf", brain_config.nodes.pattern_nodes)
self.assertEquals("./config/template_nodes.conf", brain_config.nodes.template_nodes)
self.assertIsNotNone(brain_config.binaries)
self.assertFalse(brain_config.binaries.save_binary)
self.assertFalse(brain_config.binaries.load_binary)
self.assertEquals("/tmp/y-bot.brain", brain_config.binaries.binary_filename)
self.assertFalse(brain_config.binaries.load_aiml_on_binary_fail)
self.assertIsNotNone(brain_config.braintree)
self.assertEquals("/tmp/braintree.xml", brain_config.braintree.file)
self.assertEquals("xml", brain_config.braintree.content)
self.assertIsNotNone(brain_config.files)
self.assertIsNotNone(brain_config.files.aiml_files)
self.assertEqual(["./aiml"], brain_config.files.aiml_files.files)
self.assertEqual(".aiml", brain_config.files.aiml_files.extension)
self.assertTrue(brain_config.files.aiml_files.directories)
self.assertEqual("/tmp/y-bot_errors.txt", brain_config.files.aiml_files.errors.filename)
self.assertEqual("/tmp/y-bot_duplicates.txt", brain_config.files.aiml_files.duplicates.filename)
self.assertEqual("/tmp/y-bot_conversation.txt", brain_config.files.aiml_files.conversation.filename)
self.assertIsNotNone(brain_config.files.set_files)
self.assertEqual(["./sets"], brain_config.files.set_files.files)
self.assertEqual(".txt", brain_config.files.set_files.extension)
self.assertFalse(brain_config.files.set_files.directories)
self.assertIsNotNone(brain_config.files.map_files)
self.assertEqual(["./maps"], brain_config.files.map_files.files)
self.assertEqual(".txt", brain_config.files.map_files.extension)
self.assertFalse(brain_config.files.map_files.directories)
self.assertEqual(brain_config.files.denormal, "./config/denormal.txt")
self.assertEqual(brain_config.files.normal, "./config/normal.txt")
self.assertEqual(brain_config.files.gender, "./config/gender.txt")
self.assertEqual(brain_config.files.person, "./config/person.txt")
self.assertEqual(brain_config.files.person2, "./config/person2.txt")
self.assertEqual(brain_config.files.properties, "./config/properties.txt")
self.assertEqual(brain_config.files.triples, "./config/triples.txt")
self.assertEqual(brain_config.files.preprocessors, "./config/preprocessors.conf")
self.assertEqual(brain_config.files.postprocessors, "./config/postprocessors.conf")
self.assertEqual(brain_config.files.regex_templates, "./config/regex-templates.txt")
self.assertIsNotNone(brain_config.security)
self.assertIsNotNone(brain_config.security.authorisation)
self.assertIsNotNone(brain_config.security.authentication)
self.assertIsNotNone(brain_config.services)
self.assertTrue(brain_config.services.exists("REST"))
self.assertTrue(brain_config.services.exists("Pannous"))
self.assertTrue(brain_config.services.exists("Pandora"))
self.assertTrue(brain_config.services.exists("Wikipedia"))
self.assertFalse(brain_config.services.exists("Other"))
self.assertIsNotNone(brain_config.oob)
self.assertIsNotNone(brain_config.oob.oobs())
self.assertIsNotNone(brain_config.oob.default())
self.assertIsNotNone(brain_config.oob.oob("dial"))
self.assertIsNotNone(brain_config.oob.oob("email"))
self.assertIsNotNone(brain_config.dynamics)
self.assertIsNotNone(brain_config.dynamics.dynamic_sets)
self.assertTrue("NUMBER" in brain_config.dynamics.dynamic_sets)
self.assertTrue("ROMAN" in brain_config.dynamics.dynamic_sets)
self.assertIsNotNone(brain_config.dynamics.dynamic_maps)
self.assertTrue("ROMANTODEC" in brain_config.dynamics.dynamic_maps)
self.assertTrue("DECTOROMAN" in brain_config.dynamics.dynamic_maps)
self.assertIsNotNone(brain_config.dynamics.dynamic_vars)
self.assertTrue("GETTIME" in brain_config.dynamics.dynamic_vars)
