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 = 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_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() 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_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_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_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)