def test_type3_exception(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode(condition_type=3)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(name="name1", value=TemplateWordNode("value1"), var_type=TemplateConditionNode.GLOBAL )
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(name="name2", value=TemplateWordNode("value1"), var_type=TemplateConditionNode.LOCAL )
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(name="name3", value=TemplateWordNode("value3"), var_type=TemplateConditionNode.BOT )
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
cond3 = TemplateConditionListItemNode(name="name3")
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.bot.get_conversation(self._client_context).set_property('name1', "value1")
self._client_context.brain.properties.add_property('name3', "value3")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual("", result)
def test_type3_to_xml(self):
root = TemplateNode()
node = TemplateConditionNode(condition_type=3)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(name="name1", value=TemplateWordNode("value1"), var_type=TemplateConditionNode.GLOBAL)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(name="name2", value=TemplateWordNode("value1"), var_type=TemplateConditionNode.LOCAL )
cond2.append(TemplateWordNode("Word2"))
node.append(cond2)
cond3 = TemplateConditionListItemNode(name="name3", value=TemplateWordNode("value3"), var_type=TemplateConditionNode.BOT )
cond3.append(TemplateWordNode("Word3"))
node.append(cond3)
cond4 = TemplateConditionListItemNode(name="name4")
cond4.append(TemplateWordNode("Word4"))
node.append(cond4)
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><li name="name1"><value>value1</value>Word1</li> <li var="name2"><value>value1</value>Word2</li> <li bot="name3"><value>value3</value>Word3</li> <li name="name4">Word4</li></condition></template>', xml_str)
def test_type1_node_local_match(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._client_context, "Hello")
self._client_context.bot.get_conversation(
self._client_context).record_dialog(question)
self._client_context.bot.get_conversation(
self._client_context).current_question().set_property(
"var1", "value1")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual(result, "Hello")
def test_type1_to_xml_global(self):
root = TemplateNode()
node = TemplateConditionNode("name1", TemplateWordNode("value1"), local=False)
node.append(TemplateWordNode("Hello"))
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="name1"><value>value1</value>Hello</condition></template>', xml_str)
def test_type1_to_xml_bot(self):
root = TemplateNode()
node = TemplateConditionNode("name1", TemplateWordNode("value1"), var_type=TemplateConditionNode.BOT)
node.append(TemplateWordNode("Hello"))
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 bot="name1"><value>value1</value>Hello</condition></template>', xml_str)
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", local=True, type=2)
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 var="var1"><li><value>value1</value>Word1</li> <li><value>value2</value>Word2</li> <li>Word3</li></condition></template>',
xml_str)
def test_type2_node_bot(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("cond1",
var_type=TemplateConditionNode.BOT,
condition_type=2)
self.assertIsNotNone(node)
cond1 = TemplateConditionListItemNode(
value=TemplateWordNode("value1"),
var_type=TemplateConditionNode.BOT)
cond1.append(TemplateWordNode("Word1"))
node.append(cond1)
cond2 = TemplateConditionListItemNode(
value=TemplateWordNode("value2"),
var_type=TemplateConditionNode.BOT)
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)
self._bot.brain.properties.add_property('cond1', "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def test_type2_to_xml_bot(self):
root = TemplateNode()
node = TemplateConditionNode("cond1",
var_type=TemplateConditionNode.BOT,
condition_type=2)
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 bot="cond1"><li><value>value1</value>Word1</li> <li><value>value2</value>Word2</li> <li>Word3</li></condition></template>',
xml_str)
def test_type3_node(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode(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)
self.assertEqual(len(root.children), 1)
self.bot.conversation(self.clientid)._predicates['name1'] = "value1"
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual("Word1", result)
def test_type2_node_global(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("cond1", condition_type=2)
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)
self.assertEqual(len(root.children), 1)
self._bot.conversation(self._clientid).set_property('cond1', "value2")
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(
"cond1", "value2")
result = root.resolve(self._bot, self._clientid)
self.assertIsNotNone(result)
self.assertEqual("Word2", result)
def test_type2_node_local(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("var1", local=True, type=2)
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)
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("Word2", result)
def test_type3_to_xml(self):
root = TemplateNode()
node = TemplateConditionNode(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_type1_node_global_match(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("name1", TemplateWordNode("value1"), local=False)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
self.bot.conversation(self.clientid).set_property('name1', "value1")
result = root.resolve(self.bot, self.clientid)
self.assertIsNotNone(result)
self.assertEqual(result, "Hello")
def test_type1_node_bot_nomatch(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("name1", TemplateWordNode("value1"), var_type=TemplateConditionNode.BOT)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.brain.properties.add_property('name1', "value2")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual(result, "")
def test_type1_node_global_nomatch(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateConditionNode("name1", TemplateWordNode("value1"), var_type=TemplateConditionNode.GLOBAL)
self.assertIsNotNone(node)
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual(len(root.children), 1)
self._client_context.bot.conversation(self._client_context).set_property('name1', "value2")
result = root.resolve(self._client_context)
self.assertIsNotNone(result)
self.assertEqual(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"),
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_get_predicate_value(self):
node = TemplateConditionNode()
self.assertIsNotNone(node)
self.bot.conversation(self.clientid)._predicates['name1'] = "value1"
value = node._get_predicate_value(self.bot, self.clientid, "name1", False)
self.assertEqual(value, "value1")
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")
value = node._get_predicate_value(self.bot, self.clientid, "var1", True)
self.assertEqual(value, "value2")
value = node._get_predicate_value(self.bot, self.clientid, "unknown", True)
self.assertEqual(value, "")
self.bot.brain.properties.add_property("default-get", "Unknown")
value = node._get_predicate_value(self.bot, self.clientid, "name3", False)
self.assertEqual(value, "Unknown")
def test_to_xml_defaults_unknown(self):
node = TemplateConditionNode(name="unknown", var_type=999)
self.assertEquals('<condition unknown="unknown"></condition>',
node.to_xml(self._client_context))
def test_to_xml_defaults_default(self):
node = TemplateConditionNode(
name="default", var_type=TemplateConditionVariable.DEFAULT)
self.assertEquals('<condition default="default"></condition>',
node.to_xml(self._client_context))
def test_to_xml_defaults_local(self):
node = TemplateConditionNode(name="local",
var_type=TemplateConditionVariable.LOCAL)
self.assertEquals('<condition var="local"></condition>',
node.to_xml(self._client_context))
def test_to_xml_with_value(self):
node = TemplateConditionNode(value=TemplateWordNode("3"))
self.assertEquals('<condition><value>3</value></condition>',
node.to_xml(self._client_context))
def test_to_xml_defaults(self):
node = TemplateConditionNode()
self.assertEquals('<condition></condition>',
node.to_xml(self._client_context))
def test_to_string_defaults_unknown(self):
node = TemplateConditionNode(name="unknown", var_type=999)
self.assertEquals('[CONDITION unknown="unknown"]', node.to_string())
def test_to_string_defaults_bot(self):
node = TemplateConditionNode(
name="default", var_type=TemplateConditionVariable.DEFAULT)
self.assertEquals('[CONDITION default="default"]', node.to_string())
def test_to_string_defaults_local(self):
node = TemplateConditionNode(name="local",
var_type=TemplateConditionVariable.LOCAL)
self.assertEquals('[CONDITION var="local"]', node.to_string())
def test_to_string_defaults_global(self):
node = TemplateConditionNode(name="global",
var_type=TemplateConditionVariable.GLOBAL)
self.assertEquals('[CONDITION name="global"]', node.to_string())
def test_to_string_defaults(self):
node = TemplateConditionNode()
self.assertEquals('[CONDITION name="None"]', node.to_string())
def test_resolve_unknown(self):
node = TemplateConditionNode(name="global",
value="3",
condition_type=999)
self.assertEquals("", node.resolve_to_string(self._client_context))
def __init__(self, name=None, value=None, var_type=TemplateConditionVariable.GLOBAL, loop=False, condition_type=TemplateConditionNode.BLOCK, next_value=None, next_value_step=0):
TemplateConditionNode.__init__(self, name, value, var_type, loop, condition_type)
self._next_step_count = 0
self._next_value = next_value
self._next_value_step = next_value_step
def __init__(self):
TemplateConditionNode.__init__(self)
def __init__(self):
TemplateConditionNode.__init__(self)
def __init__(self, name, value, local=False):
TemplateConditionNode.__init__(self)
self._name = name
self._value = value
self._local = local