def test_save_learnf_same_pattern(self):
config = RedisStorageConfiguration()
engine = RedisStorageEngine(config)
engine.initialise()
store = RedisLearnfStore(engine)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
pattern = ET.Element('pattern')
pattern.text = "HELLO"
topic = ET.Element('topic')
topic.text = '*'
that = ET.Element('that')
that.text = '*'
template = TemplateNode()
template.append(TemplateWordNode("Hello"))
category = LearnCategory(pattern, topic, that, template)
is_replace = False
store.save_learnf(client_context, category, is_replace)
is_replace = True
store.save_learnf(client_context, category, is_replace)
def test_bot_defaultresponses(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
self.assertEqual(bot.default_response, "")
self.assertEqual(bot.exit_response, "Bye!")
def test_bot_init_with_config(self):
bot_config = BotConfiguration()
bot_config._bot_root = BotConfiguration.DEFAULT_ROOT
bot_config._default_response = BotConfiguration.DEFAULT_RESPONSE
bot_config._exit_response = BotConfiguration.DEFAULT_EXIT_RESPONSE
bot_config._initial_question = BotConfiguration.DEFAULT_INITIAL_QUESTION
bot_config._empty_string = BotConfiguration.DEFAULT_EMPTY_STRING
bot_config._override_properties = BotConfiguration.DEFAULT_OVERRIDE_PREDICATES
bot_config._max_question_recursion = 1000
bot_config._max_question_timeout = 60
bot_config._max_search_depth = 100
bot_config._max_search_timeout = 60
client = TestClient()
bot = Bot(bot_config, client)
self.assertIsNotNone(bot.brain)
self.assertIsNone(bot.spell_checker)
self.assertIsNotNone(bot.sentence_splitter)
self.assertIsNotNone(bot.sentence_joiner)
self.assertIsNotNone(bot.conversations)
self.assertIsNotNone(bot.default_response)
self.assertIsNotNone(bot.exit_response)
self.assertIsNotNone(bot.initial_question)
self.assertTrue(bot.override_properties)
self.assertIsNotNone(bot.get_version_string)
def test_trigger_triggers(self):
config = TriggerConfiguration()
config._manager = "programytest.triggers.test_rest.MockRestTriggerManager"
config._additionals["url"] = "http://localhost/api/1.0/ask"
mgr = TriggerManager.load_trigger_manager(config)
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.assertTrue(triggered)
triggered = mgr.trigger("OTHER_EVENT", client_context)
self.assertTrue(triggered)
triggered = mgr.trigger("OTHER_EVENT", client_context, additional={"key": "value"})
self.assertTrue(triggered)
def test_conversation_operations_no_conversation(self):
config = BotConversationsConfiguration()
mgr = ConversationManager(config)
convo_dir = self.get_temp_dir() + os.sep + "storage" + os.sep + "conversations"
if os.path.exists(convo_dir):
shutil.rmtree(convo_dir)
client = TestClient()
client.add_conversation_store(convo_dir)
mgr.initialise(client.storage_factory)
client_context = client.create_client_context("user1")
conversation = mgr.get_conversation(client_context)
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
conversation.record_dialog(question1)
del mgr._conversations[client_context.userid]
mgr.save_conversation(client_context)
def test_read_write_question_properties_in_db(self):
config = SQLStorageConfiguration()
engine = SQLStorageEngine(config)
engine.initialise()
store = SQLConversationStore(engine)
client = TestClient()
client_context = client.create_client_context("user1")
store.empty()
properties1 = {"key1": "value1", "key2": "value2"}
store._write_properties_to_db(client_context, 1, 2,
ConversationPropertyDAO.QUESTION,
properties1)
store.commit()
properties2 = {}
store._read_properties_from_db(client_context, 1, 2,
ConversationPropertyDAO.QUESTION,
properties2)
self.assertEqual({"key1": "value1", "key2": "value2"}, properties2)
store.empty()
def setUp(self):
self.client = TestClient()
self.bot = Bot(config=BotConfiguration(), client=self.client)
self.bot.brain.denormals.add_to_lookup(" DOT COM ", [
re.compile('(^DOT COM | DOT COM | DOT COM$)', re.IGNORECASE),
'.COM '
])
def post_process(self, output_str):
self.client = TestClient()
context = ClientContext(self.client, "testid")
context.bot = Bot(config=BotConfiguration(), client=self.client)
context.brain = context.bot.brain
context.bot.brain.denormals.add_to_lookup(" DOT COM ", [
re.compile('(^DOT COM | DOT COM | DOT COM$)', re.IGNORECASE),
'.COM '
])
context.bot.brain.denormals.add_to_lookup(
" ATSIGN ",
[re.compile('(^ATSIGN | ATSIGN | ATSIGN$)', re.IGNORECASE), '@'])
denormalize = DenormalizePostProcessor()
punctuation = FormatPunctuationProcessor()
numbers = FormatNumbersPostProcessor()
multispaces = RemoveMultiSpacePostProcessor()
emojize = EmojizePostProcessor()
output_str = denormalize.process(context, output_str)
output_str = punctuation.process(context, output_str)
output_str = numbers.process(context, output_str)
output_str = multispaces.process(context, output_str)
output_str = emojize.process(context, output_str)
return output_str
def setUp(self):
client = TestClient()
client.add_license_keys_store()
mock_api = MockNewsApiApi()
newsapi = NewsAPI(client.license_keys, mock_api)
self.assertIsNotNone(newsapi)
mock_api.response = MockResponse(
200, {"content-type": "application/json"},
json.loads("""
{
"articles": [
{
"title": "test title",
"description": "test description",
"publishedAt": "test publishedAt",
"author": "test author",
"url": "test url",
"urlToImage": "test urlToImage"
}
]
}
"""))
def test_get_news_feed_articles_none_200_response(self):
client = TestClient()
client.add_license_keys_store()
mock_api = MockNewsApiApi()
newsapi = NewsAPI(client.license_keys, mock_api)
self.assertIsNotNone(newsapi)
mock_api.response = MockResponse(
401, {"content-type": "application/json"},
json.loads("""
{
"articles": [
{
"title": "test title",
"description": "test description",
"publishedAt": "test publishedAt",
"author": "test author",
"url": "test url",
"urlToImage": "test urlToImage"
}
]
}
"""))
mock_url = NewsAPI._format_url("testservice", "key")
articles = newsapi._get_news_feed_articles(mock_url, 10, True, False)
self.assertIsNotNone(articles)
self.assertEqual(0, len(articles))
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 test_save_braintree_xml_format(self):
config = FileStorageConfiguration()
config._categories_storage = FileStoreConfiguration(
dirs=[
os.path.dirname(__file__) + os.sep + "data" + os.sep +
"categories"
],
extension="aiml",
subdirs=False,
format="xml",
encoding="utf-8",
delete_on_start=False)
tmpdir = os.path.dirname(__file__) + os.sep + "braintree"
tmpfile = tmpdir + os.sep + "braintree.xml"
config.braintree_storage._dirs = [tmpfile]
config.braintree_storage._has_single_file = True
engine = FileStorageEngine(config)
engine.initialise()
store = FileBraintreeStore(engine)
path = store._get_dir_from_path(store._get_storage_path())
if os.path.exists(path):
shutil.rmtree(path)
self.assertFalse(os.path.exists(path))
test_client = TestClient()
client_context = test_client.create_client_context("test1")
pattern_graph = client_context.brain.aiml_parser.pattern_parser
store.save_braintree(client_context, pattern_graph)
self.assertTrue(os.path.exists(store._get_storage_path()))
shutil.rmtree(tmpdir)
self.assertFalse(os.path.exists(tmpdir))
def assert_modify_conversation_data(self, store):
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.modify_conversation_data(client_context, conversation)
store.commit()
debugInfo, _ = store.debug_conversation_data(client_context)
self.assertIsNotNone(debugInfo)
self.assertIsNotNone(debugInfo['conversations'])
conversations = debugInfo['conversations']
self.assertIsNotNone(conversations['questions'])
self.assertEqual(1, len(conversations['questions']))
question = conversations['questions'][0]
self.assertEqual(1, len(question['sentences']))
sentence = question['sentences'][0]
self.assertEqual("Hello There", sentence['question'])
self.assertEqual("Hi", sentence['response'])
def assert_conversation_storage(self,
store,
can_empty=True,
test_load=True):
if can_empty is True:
store.empty()
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)
store.commit()
if test_load is True:
conversation2 = Conversation(client_context)
store.load_conversation(client_context, conversation2)
self.assertEqual(1, len(conversation2.questions))
self.assertEqual(1, len(conversation2.questions[0].sentences))
self.assertEqual("Hello There",
conversation2.questions[0].sentences[0].text())
self.assertEqual("Hi",
conversation2.questions[0].sentences[0].response)
def test_match_context_in_db(self):
config = SQLStorageConfiguration()
engine = SQLStorageEngine(config)
engine.initialise()
store = SQLConversationStore(engine)
store.empty()
client = TestClient()
client_context = client.create_client_context("user1")
matched_context1 = MatchContext(100,
100,
sentence="Hello",
response="Hi There")
matched_context1._matched_nodes = []
matched_context1._template_node = None
store._write_match_context_to_db(client_context, 1, matched_context1)
store.commit()
matched_context2 = MatchContext(100, 100)
store._read_match_context_from_db(client_context, 1, matched_context2)
self.assertEqual(100, matched_context2.max_search_timeout)
self.assertEqual(100, matched_context2.max_search_depth)
self.assertEqual("Hello", matched_context2.sentence)
self.assertEqual("Hi There", matched_context2.response)
store.empty()
def setUp(self):
client = TestClient()
self._client_context = ClientContext(client, "testid")
self._client_context.bot = Bot(BotConfiguration(), client)
config = BotSentenceSplitterConfiguration()
self._client_context.bot._sentence_splitter = SentenceSplitter.initiate_sentence_splitter(config)
def test_sentences_in_db(self):
config = SQLStorageConfiguration()
engine = SQLStorageEngine(config)
engine.initialise()
store = SQLConversationStore(engine)
store.empty()
client = TestClient()
client_context = client.create_client_context("user1")
question1 = Question.create_from_text(client_context, "Hello There")
question1.sentence(0).response = "Hi"
question1.sentence(0)._positivity = 0.5
question1.sentence(0)._subjectivity = 0.6
store._write_sentences_to_db(client_context, 1, question1)
store.commit()
question2 = Question()
store._read_sentences_from_db(client_context, 1, question2)
self.assertEqual(1, len(question2.sentences))
self.assertEqual(0.5, question2.sentences[0].positivity)
self.assertEqual(0.6, question2.sentences[0].subjectivity)
self.assertEqual(["Hello", "There"], question2.sentences[0].words)
self.assertEqual("Hi", question2.sentences[0].response)
store.empty()
def test_exception_is_none_with_stderror(self):
client = TestClient()
client_context = ClientContext(client, "testid")
logging.getLogger().setLevel(level=logging.DEBUG)
YLogger.set_stderr("True")
YLogger.exception(client_context, "Exception Log", None)
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 setUp(self):
storage_engine = MockStorageEngine()
client = TestClient()
self.context = client.create_client_context("TESTUSER")
self.context.brain._security._account_linker = BasicAccountLinkerService(
storage_engine)
def test_save_then_load(self):
tmpdir = FileStorageConfiguration.get_temp_dir()
fullpath = tmpdir + os.sep + "braintree/braintree.bin"
if os.path.exists(fullpath):
os.remove(fullpath)
factory = self.create_storage_factory(fullpath)
config = BrainBinariesConfiguration()
manager = BinariesManager(config)
self.assertIsNotNone(manager)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
self.assertTrue(
manager.save_binary(factory, client_context.bot.brain.aiml_parser))
self.assertTrue(os.path.exists(fullpath))
aiml_parser2 = manager.load_binary(factory)
self.assertIsNotNone(aiml_parser2)
if os.path.exists(fullpath):
os.remove(fullpath)
def test_remove_html(self):
processor = RemoveHTMLPostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, "Hello <br/> World")
self.assertIsNotNone(result)
if os.name == 'posix':
self.assertEqual("Hello\nWorld", result)
elif os.name == 'nt':
self.assertEqual("Hello\r\nWorld", result)
else:
raise Exception("Unknown os [%s]" % os.name)
result = processor.process(context, "Hello <br /> World")
self.assertIsNotNone(result)
if os.name == 'posix':
self.assertEqual("Hello\nWorld", result)
elif os.name == 'nt':
self.assertEqual("Hello\r\nWorld", result)
else:
raise Exception("Unknown os [%s]" % os.name)
def test_context_dump(self):
client = TestClient("clientid")
client_context = client.create_client_context("testid")
self.assertIsNone(client_context.log_level)
client_context.dump()
def test_merge_chinese(self):
processor = MergeChinesePostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello")
self.assertIsNotNone(result)
self.assertEqual("Hello", result)
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, "你 好")
self.assertIsNotNone(result)
self.assertEqual("你好", result)
result = processor.process(context, "问 你 好")
self.assertIsNotNone(result)
self.assertEqual("问你好", result)
result = processor.process(context, "XX 你 好")
self.assertIsNotNone(result)
self.assertEqual("XX 你好", result)
result = processor.process(context, "XX 你 好 YY")
self.assertIsNotNone(result)
self.assertEqual("XX 你好 YY", result)
def test_format_numbers(self):
processor = FormatNumbersPostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "23")
self.assertIsNotNone(result)
self.assertEqual("23", result)
result = processor.process(context, "23.45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23. 45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23 . 45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23,450")
self.assertIsNotNone(result)
self.assertEqual("23,450", result)
result = processor.process(context, "23, 450")
self.assertIsNotNone(result)
self.assertEqual("23,450", result)
result = processor.process(context, "23, 450, 000")
self.assertIsNotNone(result)
self.assertEqual("23,450,000", result)
def test_ask_question_without_triggermgr(self):
bot_config = BotConfiguration()
client = TestClient()
client._trigger_mgr = None
bot = Bot(bot_config, client)
bot.ask_question(self._client_context, "HELLO WORLD")
def test_bot_chat_loop(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
self.assertIsInstance(bot, Bot)
bot.configuration._default_response = "Sorry, I don't have an answer for that right now"
response = bot.ask_question(self._client_context, "hello")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
response = bot.ask_question(self._client_context, "hello again")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
response = bot.ask_question(self._client_context, "goodbye")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
conversation = bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
self.assertEqual(conversation.previous_nth_question(2).sentence(0).text(), "hello")
self.assertEqual(conversation.previous_nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).text(), "hello again")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).text(), "goodbye")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).response, "Sorry, I don't have an answer for that right now")
def test_save_learnf(self):
config = FileStorageConfiguration()
tmpdir = os.path.dirname(__file__) + os.sep + "learnf"
config.learnf_storage._dirs = [tmpdir]
engine = FileStorageEngine(config)
engine.initialise()
store = FileLearnfStore(engine)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
learnf_path = store._get_storage_path()
learnf_fullpath = store.create_learnf_path(client_context, learnf_path)
if os.path.exists(learnf_fullpath):
os.remove(learnf_fullpath)
self.assertFalse(os.path.exists(learnf_fullpath))
template = TemplateNode()
template.append(TemplateWordNode("Hello"))
category = LearnCategory("HELLO *", "*", "*", template)
store.save_learnf(client_context, category)
self.assertTrue(os.path.exists(learnf_fullpath))
shutil.rmtree(tmpdir)
self.assertFalse(os.path.exists(tmpdir))
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_save_learnf_with_exception(self):
config = FileStorageConfiguration()
tmpdir = os.path.dirname(__file__) + os.sep + "learnf"
config.learnf_storage._dirs = [tmpdir]
engine = FileStorageEngine(config)
engine.initialise()
store = FileLearnfStore(engine)
test_client = TestClient()
client_context = test_client.create_client_context("test1")
learnf_path = store._get_storage_path()
learnf_fullpath = store.create_learnf_path(client_context, learnf_path)
if os.path.exists(learnf_fullpath):
os.remove(learnf_fullpath)
self.assertFalse(os.path.exists(learnf_fullpath))
pattern = ET.Element('pattern')
pattern.text = "HELLO"
topic = ET.Element('topic')
topic.text = '*'
that = ET.Element('that')
that.text = '*'
template = TemplateNode()
template.append(TemplateWordNode("Hello"))
category = LearnCategory(pattern, topic, that, template)
self.assertFalse(store.save_learnf(client_context, category))
