def test_xml_tree_simple(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateWordNode("Word2"))
xml = node.xml_tree(self._client_context)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template>Word1 Word2</template>", xml_str)
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._client_context)
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_to_xml(self):
root = TemplateNode()
root.append(TemplateIdNode())
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><id /></template>", xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateAddTripleNode(subj=TemplateWordNode("S"), pred=TemplateWordNode("P"), obj=TemplateWordNode("O"))
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><addtriple><subj>S</subj><pred>P</pred><obj>O</obj></addtriple></template>", xml_str)
def test_to_xml_no_default_star(self):
root = TemplateNode()
node = TemplateThatNode(question=3, sentence=-1)
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><that index="3,*" /></template>', xml_str)
def test_to_xml_no_words(self):
root = TemplateNode()
node = TemplateFirstNode()
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><first /></template>", xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateThatStarNode()
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><thatstar /></template>", xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateInputNode(index=3)
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><input index="3" /></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateSRAINode()
root.append(node)
node.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><srai>Hello</srai></template>", xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateBotNode()
node.name = TemplateWordNode("name")
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><bot name="name" /></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateThinkNode()
root.append(node)
node.append(TemplateWordNode("Test"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><think>Test</think></template>", xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateSearchNode()
root.append(node)
node.append(TemplateWordNode("programr"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><search>programr</search></template>",
xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateDateNode()
root.append(node)
node.append(TemplateWordNode("Mon Sep 30 07:06:05 2013"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><date format="%c">Mon Sep 30 07:06:05 2013</date></template>',
xml_str)
def test_to_xml_no_timeout(self):
root = TemplateNode()
node = TemplateSystemNode()
root.append(node)
node.append(TemplateWordNode('echo "Hello World"'))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><system>echo "Hello World"</system></template>',
xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateMapNode()
node.name = TemplateWordNode("COLOURS")
node.append(TemplateWordNode("BLACK"))
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><map name="COLOURS">BLACK</map></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
xml = TemplateXMLNode()
xml._name = "dial"
root.append(xml)
xml.append(TemplateWordNode("07777777777"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><dial>07777777777</dial></template>",
xml_str)
def test_to_xml_local_set(self):
root = TemplateNode()
node = TemplateSetNode()
node.name = TemplateWordNode("name")
node.local = True
root.append(node)
node.append(TemplateWordNode("keith"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><set var="name">keith</set></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateIntervalNode()
node.interval_format = TemplateWordNode("%c")
node.style = TemplateWordNode("years")
node.interval_from = TemplateWordNode("Thu Oct 6 16:35:11 2014")
node.interval_to = TemplateWordNode("Fri Oct 7 16:35:11 2016")
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><interval format="%c" style="years"><from>Thu Oct 6 16:35:11 2014</from><to>Fri Oct 7 16:35:11 2016</to></interval></template>', xml_str)
def test_xml_tree_simple_composite(self):
node = TemplateNode()
node.append(TemplateWordNode("Word1"))
node.append(TemplateIdNode())
srai = TemplateSRAINode()
srai.append(TemplateWordNode("Srai1"))
node.append(srai)
node.append(TemplateWordNode("Word2"))
xml = node.xml_tree(self._client_context)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
"<template>Word1 <id /> <srai>Srai1</srai> Word2</template>",
xml_str)
def test_to_xml(self):
root = TemplateNode()
random = TemplateRandomNode()
root.append(random)
random.append(TemplateWordNode("Test1"))
random.append(TemplateWordNode("Test2"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
"<template><random><li>Test1</li><li>Test2</li></random></template>",
xml_str)
def test_to_xml_with_attribs(self):
root = TemplateNode()
xml = TemplateXMLNode()
xml._name = "dial"
xml._attribs['leave_message'] = "true"
root.append(xml)
xml.append(TemplateWordNode("07777777777"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><dial leave_message="true">07777777777</dial></template>',
xml_str)
def test_to_xml_service(self):
root = TemplateNode()
node = TemplateSRAIXNode()
node.service = "api"
root.append(node)
node.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
'<template><sraix service="api">Hello</sraix></template>', xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateFirstNode()
root.append(node)
word1 = TemplateWordNode("Word1")
node.append(word1)
word2 = TemplateWordNode("Word2")
node.append(word2)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><first>Word1 Word2</first></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_to_xml_service_no_content(self):
root = TemplateNode()
node = TemplateAuthoriseNode()
node.role = "root"
self.assertIsNotNone(node)
root.append(node)
self.assertEqual(len(root.children), 1)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><authorise role="root" /></template>',
xml_str)
def test_to_xml(self):
root = TemplateNode()
learn = TemplateLearnNode()
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)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual(
"<template><learn><category><pattern>HELLO LEARN</pattern><topic>*</topic><that>*</that><template>LEARN</template></category></learn></template>",
xml_str)
def test_to_xml(self):
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateExtensionNode()
node.path = "programrtest.parser.template.node_tests.test_extension.MockExtension"
node.append(TemplateWordNode("Test"))
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><extension path="programrtest.parser.template.node_tests.test_extension.MockExtension">Test</extension></template>',
xml_str)
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_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._client_context)
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)
