def test_call_PublishedBot(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._locale = TemplateWordNode('ja-JP')
node._time = TemplateWordNode('2019-01-01T00:00:00+09:00')
node._userId = TemplateWordNode('1234567890')
node._topic = TemplateWordNode('*')
node._deleteVariable = TemplateWordNode('false')
node._metadata = TemplateWordNode('1234567890')
node._config = TemplateWordNode('{"config":{"logLevel":"debug"}}')
node.append(TemplateWordNode("Hello"))
root.append(node)
self.set_collection_botnames()
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())
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response('{"response": "asked"}')
self.assertEqual("asked", node.resolve(self._client_context))
self.assertEqual('{"testbot": {"response": "asked"}}',
question.property('__SUBAGENT_EXTBOT__'))
def test_node_local_nomatch(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateType1ConditionNode("var1",
TemplateWordNode("value1"),
local=True)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
question = Question.create_from_text("Hello")
self.bot.conversation(self.clientid).record_dialog(question)
self.bot.conversation(self.clientid).current_question().set_predicate(
"var1", "value2")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual(result, "")
def test_node_with_invalid_index(self):
root = TemplateNode()
node = TemplateSrNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1)
context.add_match(Match(Match.TOPIC, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
def test_to_xml_global(self):
root = TemplateNode()
node = TemplateType2ConditionNode("cond1")
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(value=TemplateWordNode("value1"))
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(value=TemplateWordNode("value2"))
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode()
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><condition name="cond1"><li><value>value1</value>Word1</li><li><value>value2</value>Word2</li><li>Word3</li></condition></template>',
xml_str)
def test_node_no_star(self):
root = TemplateNode()
node = TemplateThatStarNode()
root.append(node)
conversation = Conversation(self._client_context)
question = Question.create_from_text(
self._client_context, "Hello world",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(
self._client_context, "How are you",
self._client_context.bot.sentence_splitter)
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
self.assertEqual("", root.resolve(self._client_context))
def test_tuples(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
select = TemplateSelectNode()
self.assertIsNotNone(select)
node = TemplateGetNode()
node.name = TemplateWordNode("?x ?y")
node.tuples = select
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual("[GET [Tuples] - ([WORD]?x ?y)]", node.to_string())
xml = root.xml_tree(self._bot, self._clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><get var="?x ?y"><select /></get></template>', xml_str)
def test_delete_learnf(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)
store.delete_learnf(client_context)
def test_resolve_no_defaults_inside_topic(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateTopicStarNode(index=1)
self.assertIsNotNone(node)
self.assertIsInstance(node.index, TemplateNode)
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = Conversation(self._client_context)
question = Question.create_from_text(self._client_context,
"Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._client_context,
"How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.tokenizer)
context.add_match(Match(Match.TOPIC, match, "Matched"))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._client_context.bot._conversation_mgr._conversations[
"testid"] = conversation
self.assertEqual("Matched", node.resolve(self._client_context))
def test_resolve_with_defaults(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateInputNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(0, node.index)
conversation = Conversation("testid", self.bot)
question = Question.create_from_text("Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
self.bot._conversations["testid"] = conversation
response = root.resolve(self.bot, "testid")
self.assertIsNotNone(response)
self.assertEqual(response, "Hello world")
def test_node_with_star_with_none(self):
root = TemplateNode()
node = TemplateThatStarNode()
root.append(node)
conversation = Conversation("testid", self._bot)
question = Question.create_from_text(self._bot.brain.tokenizer, "Hello world")
question.current_sentence()._response = "Hello matey"
conversation.record_dialog(question)
question = Question.create_from_text(self._bot.brain.tokenizer, "How are you")
question.current_sentence()._response = "Very well thanks"
conversation.record_dialog(question)
match = PatternOneOrMoreWildCardNode("*")
context = MatchContext(max_search_depth=100, max_search_timeout=-1, tokenizer=self._bot.brain.tokenizer)
context.add_match(Match(Match.THAT, match, None))
question.current_sentence()._matched_context = context
conversation.record_dialog(question)
self._bot._conversations["testid"] = conversation
self.assertEqual("", root.resolve(self._bot, self._clientid))
def test_type3_to_xml(self):
root = TemplateNode()
node = TemplateConditionNode(condition_type=3)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(name="name1", value=TemplateWordNode("value1"))
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(name="name2", value=TemplateWordNode("value1"), local=True )
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(name="name3")
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><condition><li name="name1"><value>value1</value>Word1</li> <li var="name2"><value>value1</value>Word2</li> <li name="name3">Word3</li></condition></template>', xml_str)
def test_call_PublishedBot_topic(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.append(TemplateWordNode("Hello"))
root.append(node)
conversation = self._client_context.bot.get_conversation(
self._client_context)
conversation.set_property('topic', 'morning')
self.set_collection_botnames()
self.assertEqual("asked", node.resolve(self._client_context))
node._topic = TemplateWordNode("evening")
self.assertEqual("asked", node.resolve(self._client_context))
def test_to_xml_GeneralRest(self):
root = TemplateNode()
node = TemplateSRAIXNode()
node._default = "unknown"
root.append(node)
node._host = TemplateWordNode("hostname")
node._method = TemplateWordNode("POST")
node._query = TemplateWordNode('"userid":"1234567890"')
node._header = TemplateWordNode('"Content-Type":"application/json"')
node._body = TemplateWordNode("Hello")
with self.assertRaises(Exception):
node.resolve_to_string(self._client_context)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><sraix default="unknown"><host>hostname</host><method>POST</method><query>"userid":"1234567890"</query>'
+
'<header>"Content-Type":"application/json"</header><body>Hello</body>'
+ '</sraix></template>', xml_str)
def test_check_child_is_wildcard_arrow(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
wildcard._0ormore_arrow = PatternZeroOrMoreWildCardNode('^')
wildcard._0ormore_arrow._template = PatternTemplateNode(TemplateNode())
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._bot.brain.tokenizer)
sentence = Sentence(self._bot.brain.tokenizer, "TEST SENTENCE")
match = wildcard.check_child_is_wildcard("", self._bot, self._clientid,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
context = MatchContext(max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._bot.brain.tokenizer)
sentence = Sentence(self._bot.brain.tokenizer, "TEST")
match = wildcard.check_child_is_wildcard("", self._bot, self._clientid,
context, sentence, 0,
Match.WORD, 0)
self.assertIsNotNone(match)
def test_type2_to_xml_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("var1", var_type=TemplateConditionNode.LOCAL, condition_type=2)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(value=TemplateWordNode("value1"), var_type=TemplateConditionNode.LOCAL)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(value=TemplateWordNode("value2"), var_type=TemplateConditionNode.LOCAL)
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode()
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><condition var="var1"><li><value>value1</value>Word1</li> <li><value>value2</value>Word2</li> <li>Word3</li></condition></template>', xml_str)
def test_node(self):
test_bot = Bot(Brain(BrainConfiguration()), BotConfiguration())
topic_element = ET.fromstring('<topic>*</topic>')
that_element = ET.fromstring('<that>*</that>')
pattern_element = ET.fromstring("<pattern>hello world</pattern>")
test_bot.brain._aiml_parser.pattern_parser.add_pattern_to_graph(
pattern_element, topic_element, that_element, None)
test_bot.brain._sets_collection.add_set("testset",
["val1", "val2", "val3"])
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateVocabularyNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEquals(root.resolve(test_bot, "testid"), '5')
def test_nestedrandom(self):
root = TemplateNode()
self.assertIsNotNone(root)
random1 = TemplateRandomNode()
random1.append(TemplateWordNode("Test1"))
random1.append(TemplateWordNode("Test2"))
self.assertEqual(len(random1.children), 2)
random2 = TemplateRandomNode()
random2.append(TemplateWordNode("Test3"))
random2.append(TemplateWordNode("Test4"))
self.assertEqual(len(random1.children), 2)
random3 = TemplateRandomNode()
random3.append(random1)
random3.append(random1)
random3.append(random2)
root.append(random3)
resolved = root.resolve(self._client_context)
self.assertIsNotNone(resolved)
self.assertOneOf(resolved, ["Test1", "Test2", "Test3", "Test4"])
def test_node(self):
topic_element = ET.fromstring('<topic>*</topic>')
that_element = ET.fromstring('<that>*</that>')
pattern_element = ET.fromstring("<pattern>hello world</pattern>")
self._client_context.brain._aiml_parser.pattern_parser.add_pattern_to_graph(
pattern_element, topic_element, that_element, None)
self._client_context.brain.sets._sets["TESTSET"] = [
"VAL1", "VAL2", "VAL3"
]
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateVocabularyNode()
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
self.assertEqual(root.resolve(self._client_context), '14')
def test_typedata_set(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSetNode()
self.assertIsNotNone(node)
node.name = TemplateWordNode("name")
node.property_type = "data"
node.append(TemplateWordNode("keith"))
root.append(node)
self.assertEqual(len(root.children), 1)
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
result = node.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("keith", result)
self.assertEqual("keith", conversation.data_property("name"))
def test_node(self):
if os.path.exists('/tmp/leanf.aiml'):
os.remove('/tmp/leanf.aiml')
root = TemplateNode()
self.assertIsNotNone(root)
learn = TemplateLearnfNode()
self.assertIsNotNone(learn)
learn_cat = LearnCategory(
ET.fromstring("<pattern>HELLO LEARN</pattern>"),
ET.fromstring("<topic>*</topic>"), ET.fromstring("<that>*</that>"),
TemplateWordNode("LEARN"))
learn.append(learn_cat)
root.append(learn)
self.assertEqual(1, len(root.children))
self.bot.brain.configuration.defaults._learn_filename = '/tmp/learnf.aiml'
resolved = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(resolved)
self.assertEqual("", resolved)
self.assertTrue(os.path.exists('/tmp/learnf.aiml'))
def test_type2_node_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("var1",
var_type=TemplateConditionNode.LOCAL,
condition_type=2)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(
value=TemplateWordNode("value1"),
var_type=TemplateConditionNode.LOCAL)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(
value=TemplateWordNode("value2"),
var_type=TemplateConditionNode.LOCAL)
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode()
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
self._bot.conversation(self._clientid).record_dialog(question)
self._bot.conversation(self._clientid).current_question().set_property(
"var1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def test_type1_node_local_nomatch(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("var1",
TemplateWordNode("value1"),
var_type=TemplateConditionNode.LOCAL)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
question = Question.create_from_text(self._bot.brain.tokenizer,
"Hello")
self._bot.conversation(self._clientid).record_dialog(question)
self._bot.conversation(self._clientid).current_question().set_property(
"var1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual(result, "")
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))
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)
store.save_learnf(client_context, category)
self.assertTrue(os.path.exists(learnf_fullpath))
shutil.rmtree(tmpdir)
self.assertFalse(os.path.exists(tmpdir))
def test_node_no_conversation(self):
root = TemplateNode()
node = TemplateStarNode()
root.append(node)
self.assertEqual("", root.resolve(self._client_context))
def test_to_xml_simple(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateWordNode("Word2"))
self.assertEqual("Word1 Word2", node.to_xml(None, None))
def test_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
def test_parse_template_node(self):
node = TemplateNode()
pattern = ET.fromstring("<template>Test</template>")
node.parse_template_node(self._client_context.brain.aiml_parser.template_parser, pattern)
self.assertEquals(1, len(node.children))
self.assertEquals("Test", node.children[0].word)
def test_parse_template_node_empty(self):
node = TemplateNode()
pattern = ET.fromstring("<template></template>")
node.parse_template_node(self._client_context.brain.aiml_parser.template_parser, pattern)
self.assertEquals(0, len(node.children))
def test_to_xml_simple(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateWordNode("Word2"))
self.assertEqual("Word1 Word2", node.to_xml(self._client_context))
def test_to_xml(self):
root = TemplateNode()
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template />", xml_str)
