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_to_xml(self):
root = TemplateNode()
root.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>Hello</template>", xml_str)
def test_to_xml(self):
root = TemplateNode()
root.append(TemplateIdNode())
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><id /></template>", xml_str)
def test_to_xml_defaults(self):
root = TemplateNode()
node = TemplateThatNode()
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 /></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(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_defaults(self):
root = TemplateNode()
node = TemplateResponseNode()
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><response /></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.bot, self.clientid)
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_defaults(self):
root = TemplateNode()
node = TemplateRequestNode(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><request index="3" /></template>', xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateResponseNode(position=2, index=3)
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><response index="3" position="2" /></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 = TemplateSearchNode()
root.append(node)
node.append(TemplateWordNode("programy"))
xml = root.xml_tree(self._bot, self._clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><search>programy</search></template>", xml_str)
def test_to_xml_no_default_star(self):
root = TemplateNode()
node = TemplateThatStarNode(question=3, sentence=-1)
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><thatstar index="3,*" /></template>',
xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateThinkNode()
root.append(node)
node.append(TemplateWordNode("Test"))
xml = root.xml_tree(self._bot, self._clientid)
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 = TemplateSystemNode()
root.append(node)
node.append(TemplateWordNode('echo "Hello World"'))
xml = root.xml_tree(self.bot, self.clientid)
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_local(self):
root = TemplateNode()
node = TemplateConditionListItemNode("name1", value=TemplateWordNode("value1"), local=True)
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><li var="name1"><value>value1</value>Hello</li></template>', xml_str)
def test_to_xml_no_defaults(self):
root = TemplateNode()
node = TemplateTopicStarNode(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><topicstar index="3" /></template>',
xml_str)
def test_to_xml_global(self):
root = TemplateNode()
node = TemplateType1ConditionNode("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_to_xml(self):
root = TemplateNode()
node = TemplateVocabularyNode()
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><vocabulary>Test</vocabulary></template>", xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateSRAINode()
root.append(node)
node.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self.bot, self.clientid)
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_no_defaults(self):
root = TemplateNode()
node = TemplateResponseNode(index=3)
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><response index="3" /></template>',
xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateSentenceNode()
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><sentence>Test</sentence></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(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 = TemplateSRAINode()
root.append(node)
node.append(TemplateWordNode("Hello"))
xml = root.xml_tree(self.bot, self.clientid)
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 = TemplateGenderNode()
root.append(node)
node.append(TemplateWordNode("Test"))
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><gender>Test</gender></template>", xml_str)
def test_to_xml_typevar_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.property_type = "var"
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><get var="name" /></template>', xml_str)
def test_to_xml_vars(self):
root = TemplateNode()
node = TemplateSelectNode(vars=["?x", "?y"])
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><select><vars>?x ?y</vars></select></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_defaults(self):
root = TemplateNode()
node = TemplateDateNode()
root.append(node)
node.append(TemplateWordNode("Mon Sep 30 07:06:05 2013"))
xml = root.xml_tree(self.bot, self.clientid)
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(self):
root = TemplateNode()
query = RDFQuery(subject=TemplateWordNode("S"), predicate=TemplateWordNode("P"), object=TemplateWordNode("O"))
statement = RDFUniqueStatement(query)
node = TemplateUniqNode(statement)
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><uniq><subj>S</subj><pred>P</pred><obj>O</obj></uniq></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_local_get(self):
root = TemplateNode()
node = TemplateGetNode()
node.name = TemplateWordNode("name")
node.local = True
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><get var="name" /></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_with_timeout(self):
root = TemplateNode()
node = TemplateSystemNode()
node.timeout = 1000
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 timeout="1000">echo "Hello World"</system></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(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(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_default(self):
root = TemplateNode()
log = TemplateLogNode()
log.append(TemplateWordNode("Log Test"))
root.append(log)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><log level="debug">Log Test</log></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_no_service(self):
root = TemplateNode()
node = TemplateSRAIXNode()
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>Hello</sraix></template>', xml_str)
def test_to_xml_default(self):
root = TemplateNode()
log = TemplateLogNode()
log.append(TemplateWordNode("Log Test"))
root.append(log)
xml = root.xml_tree(self._client_context)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><log level="debug">Log Test</log></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.bot, self.clientid)
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_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.bot, self.clientid)
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 = TemplateDeleteTripleNode(
RDFEntity(rdf_subject="S", rdf_predicate="P", rdf_object="O"))
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><deletetriple><subj>S</subj><pred>P</pred><obj>O</obj></deletetriple></template>",
xml_str)
def test_to_xml_no_service(self):
root = TemplateNode()
node = TemplateSRAIXNode()
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>Hello</sraix></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_not_query(self):
root = TemplateNode()
not_query = NotQuery("subject", "predicate", "object")
node = TemplateSelectNode(queries=[not_query])
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><select><notq><subj>subject</subj><pred>predicate</pred><obj>object</obj></notq></select></template>",
xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateIntervalNode()
node.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.bot, self.clientid)
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_to_xml_unknown(self):
root = TemplateNode()
log = TemplateLogNode()
log.level = None
log.append(TemplateWordNode("Log Test"))
root.append(log)
xml = root.xml_tree(self._bot, self._clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual('<template><log>Log Test</log></template>', xml_str)
def test_to_xml_nluslot(self):
root = TemplateNode()
node = TemplateNluSlotNode()
node._slotName = TemplateWordNode("nlu_slot")
node._itemName = TemplateWordNode("entity")
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><nluslot><name>nlu_slot</name><item>entity</item></nluslot></template>',
xml_str)
def test_to_xml(self):
root = TemplateNode()
node = TemplateRestNode()
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><rest>Word1 Word2</rest></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_to_xml(self):
root = TemplateNode()
learn = TemplateLearnfNode()
learn._pattern = ET.fromstring("<pattern>HELLO LEARN</pattern>")
learn._topic = ET.fromstring("<topic>*</topic>")
learn._that = ET.fromstring("<that>*</that>")
learn._template = TemplateWordNode("LEARN")
root.append(learn)
xml = root.xml_tree(self.bot, self.clientid)
self.assertIsNotNone(xml)
xml_str = ET.tostring(xml, "utf-8").decode("utf-8")
self.assertEqual("<template><learnf><pattern>HELLO LEARN</pattern><topic>*</topic><that>*</that><template>LEARN</template></learnf></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(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 = "programytest.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="programytest.parser.template.node_tests.test_extension.MockExtension">Test</extension></template>', xml_str)
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_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)
