Data Form tests and clean up implementation

darcs-hash:20061127214039-86b55-9ca97b0e1c2b39510505f9faec1dda148cf73288.gz

run_tests.py

@@ -63,7 +63,7 @@ if __name__ == '__main__':
 #    jcl_suite.addTest(FeederComponent_TestCase('test_handle_tick'))
 #    jcl_suite.addTest(FeederComponent_TestCase('test_handle_get_register_new'))
 #    jcl_suite = unittest.TestSuite((feeder_component_suite))
-#    jcl_suite = unittest.TestSuite((account_suite))
+#    jcl_suite = unittest.TestSuite((dataform_suite))
     jcl_suite = unittest.TestSuite((component_suite, \
                                     feeder_component_suite, \
                                     feeder_suite, \

src/jcl/jabber/component.py

@@ -356,6 +356,7 @@ class JCLComponent(Component, object):
         query = info_query.get_query()
         x_data = DataForm()
         x_data.from_xml(query.children)
+
         name = x_data.get_field_value("name")
         if name is None:
             info_query = info_query.make_error_response(\

src/jcl/jabber/x.py

@@ -31,19 +31,19 @@ class Option(object):
     """Option value for list field
     """
     def __init__(self, label, value):
-        self.__label = label
+        self.label = label
-        self.__value = value
+        self.value = value
     
     def get_xml(self, parent):
         """Return XML Option representation from
-        self.__label and self.__value and attach it to parent
+        self.label and self.value and attach it to parent
         """
         if parent is None:
             option = common_doc.newChild(None, "option", None)
         else:
             option = parent.newChild(None, "option", None)
-        option.setProp("label", self.__label)
+        option.setProp("label", self.label)
-        option.newChild(None, "value", self.__value)
+        option.newChild(None, "value", self.value)
         return option
 
 class Field(object):
@@ -51,17 +51,17 @@ class Field(object):
     """
     def __init__(self, field_type, label, var, value, required = False):
         self.type = field_type
-        self.__label = label
+        self.label = label
-        self.__var = var
+        self.var = var
         self.value = value
-        self.__options = []
+        self.options = []
         self.required = required
 
     def add_option(self, label, value):
         """Add an Option to this field
         """
         option = Option(label, value)
-        self.__options.append(option)
+        self.options.append(option)
         return option
 
     def get_xml(self, parent):
@@ -73,15 +73,15 @@ class Field(object):
         else:
             field = parent.newChild(None, "field", None)
         field.setProp("type", self.type)
-        if not self.__label is None:
+        if not self.label is None:
-            field.setProp("label", self.__label)
+            field.setProp("label", self.label)
-        if not self.__var is None:
+        if not self.var is None:
-            field.setProp("var", self.__var)
+            field.setProp("var", self.var)
         if self.value:
             field.newChild(None, "value", self.value)
         if self.required:
             field.newChild(None, "required", None)
-        for option in self.__options:
+        for option in self.options:
             option.get_xml(field)
         return field
 
@@ -136,35 +136,37 @@ class DataForm(object):
     def from_xml(self, node):
         """Populate this X object from an XML representation
         """
-## TODO : test node type and ns and clean that loop !!!!
+        context = common_doc.xpathNewContext()
-        while node and node.type != "element":
+        context.setContextNode(node)
-            node = node.next
+        context.xpathRegisterNs("jxd", "jabber:x:data")
-        child = node.children
+        fields_node = context.xpathEval("jxd:field")
-        while child:
+        for field_node in fields_node:
-## TODO : test child type (element) and ns (jabber:x:data)
+            if field_node.hasProp("type"): 
-            if child.type == "element" and child.name == "field":
+                field_type = field_node.prop("type")
-                if child.hasProp("type"): 
+            else:
-                    field_type = child.prop("type")
+                field_type = ""
-                else:
-                    field_type = ""
 
-                if child.hasProp("label"): 
+            if field_node.hasProp("label"): 
-                    label = child.prop("label")
+                label = field_node.prop("label")
-                else:
+            else:
-                    label = ""
+                label = ""
 
-                if child.hasProp("var"): 
+            if field_node.hasProp("var"): 
-                    var = child.prop("var")
+                var = field_node.prop("var")
-                else:
+            else:
-                    var = ""
+                var = ""
 
-                xval = child.children
+            field_context = common_doc.xpathNewContext()
-                while xval and xval.name != "value":
+            field_context.setContextNode(field_node)
-                    xval = xval.next
+            field_context.xpathRegisterNs("jxd", "jabber:x:data")
-                if xval:
+            fields_value_node = field_context.xpathEval("jxd:value")
-                    value = xval.getContent()
+            if len(fields_value_node) > 0:
-                else:
+                value = fields_value_node[0].content
-                    value = ""
+            else:
-                field = Field(field_type, label, var, value)
+                value = ""
-                self.fields[var] = field
+            self.add_field(field_type = field_type, \
-            child = child.next
+                           label = label, \
+                           var = var, \
+                           value = value)
+            field_context.xpathFreeContext()
+        context.xpathFreeContext()

tests/jcl/jabber/test_x.py

@@ -22,11 +22,154 @@
 
 import unittest
 
+from jcl.jabber.x import *
+from pyxmpp.stanza import common_doc
+import libxml2
+
 class DataForm_TestCase(unittest.TestCase):
-    pass
+    def setUp(self):
+        self.data_form = DataForm()
+
+    def tearDown(self):
+        self.data_form = None
+        
+    def test_add_field(self):
+        self.data_form = DataForm()
+        field = self.data_form.add_field(field_type = "single-text", \
+                                         label = "Name", \
+                                         var = "name", \
+                                         value = "jcl")
+        self.assertEquals(self.data_form.fields["name"], field)
+        self.assertTrue(field in self.data_form.fields_tab)
+        self.assertEquals(field.type, "single-text")
+        self.assertEquals(field.label, "Name")
+        self.assertEquals(field.var, "name")
+        self.assertEquals(field.value, "jcl")
+        self.assertEquals(field.required, False)
+
+    def test_add_required_field(self):
+        self.data_form = DataForm()
+        field = self.data_form.add_field(field_type = "single-text", \
+                                         label = "Name", \
+                                         var = "name", \
+                                         value = "jcl", \
+                                         required = True)
+        self.assertEquals(self.data_form.fields["name"], field)
+        self.assertTrue(field in self.data_form.fields_tab)
+        self.assertEquals(field.type, "single-text")
+        self.assertEquals(field.label, "Name")
+        self.assertEquals(field.var, "name")
+        self.assertEquals(field.value, "jcl")
+        self.assertEquals(field.required, True)
+
+    def test_get_field_value(self):
+        self.data_form.add_field(field_type = "single-text", \
+                                 var = "name", \
+                                 value = "jcl")
+        self.assertEquals(self.data_form.get_field_value("name"), \
+                          "jcl")
+
+    def test_get_field_value_not_exist(self):
+        self.assertEquals(self.data_form.get_field_value("name"), \
+                          None)
+
+    def test_get_field_value_post_func(self):
+        self.data_form.add_field(field_type = "single-text", \
+                                 var = "name", \
+                                 value = "jcl")
+        self.assertEquals(self.data_form.get_field_value("name", \
+                            post_func = (lambda value: "_" + value + "_")), \
+                          "_jcl_")
+
+    def test_get_field_value_post_func(self):
+        self.assertEquals(self.data_form.get_field_value("name", \
+            default_func = (lambda field_name: "no '" + field_name + "' field")), \
+                          "no 'name' field")
+
+    def test_attach_xml(self):
+        parent_node = common_doc.newChild(None, "iq", None)
+        self.data_form.title = "JCL Form"
+        self.data_form.instructions = "Fill the form"
+        self.data_form.add_field(label = "label1", \
+                                 var = "var1")
+        self.data_form.add_field(label = "label2", \
+                                 var = "var2")
+        self.data_form.xmlns = "jabber:x:data"
+        data_form_node = self.data_form.attach_xml(parent_node)
+        context = common_doc.xpathNewContext()
+        context.setContextNode(parent_node)
+        context.xpathRegisterNs("jxd", "jabber:x:data")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:title")[0].content, "JCL Form")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:instructions")[0].content, "Fill the form")
+        self.assertEquals(len(context.xpathEval("jxd:x/jxd:field")), 2)
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[0].prop("type"), "fixed")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[0].prop("label"), "label1")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[0].prop("var"), "var1")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[1].prop("type"), "fixed")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[1].prop("label"), "label2")
+        self.assertEquals(context.xpathEval("jxd:x/jxd:field")[1].prop("var"), "var2")
+        context.xpathFreeContext()
+
+    def test_from_xml(self):
+        xml_buffer = "<x xmlns='jabber:x:data'>" \
+        "<field type='text-single' var='var1'><value>value1</value></field>" \
+        "<field type='text-single' var='var2'><value>value2</value></field>" \
+        "</x>"
+        xml_node = libxml2.parseMemory(xml_buffer, len(xml_buffer))
+        self.data_form.from_xml(xml_node.children)
+        self.assertEquals(len(self.data_form.fields_tab), 2)
+        field1 = self.data_form.fields["var1"]
+        self.assertEquals(field1.type, "text-single")
+        self.assertEquals(field1.var, "var1")
+        self.assertEquals(field1.value, "value1")
+        field2 = self.data_form.fields["var2"]
+        self.assertEquals(field2.type, "text-single")
+        self.assertEquals(field2.var, "var2")
+        self.assertEquals(field2.value, "value2")
         
 class Field_TestCase(unittest.TestCase):
-    pass
+    def test_get_xml_no_option_required(self):
+        field = Field(field_type = "text-single", \
+                      label = "Name", \
+                      var = "name", \
+                      value = "myaccount", \
+                      required = True)
+        parent_node = common_doc.newChild(None, "x", None)
+        xml_field = field.get_xml(parent_node)
+        self.assertEquals(xml_field.prop("type"), "text-single")
+        self.assertEquals(xml_field.prop("label"), "Name")
+        self.assertEquals(xml_field.prop("var"), "name")
+        self.assertEquals(xml_field.xpathEval("value")[0].content, "myaccount")
+        self.assertEquals(len(xml_field.xpathEval("required")), 1)
+
+    def test_get_xml_with_option(self):
+        field = Field(field_type = "text-single", \
+                      label = "Name", \
+                      var = "name", \
+                      value = "myaccount")
+        field.add_option("test_option", "option_value")
+        parent_node = common_doc.newChild(None, "x", None)
+        xml_field = field.get_xml(parent_node)
+        self.assertEquals(xml_field.prop("type"), "text-single")
+        self.assertEquals(xml_field.prop("label"), "Name")
+        self.assertEquals(xml_field.prop("var"), "name")
+        self.assertEquals(xml_field.xpathEval("value")[0].content, "myaccount")
+        self.assertEquals(\
+            xml_field.xpathEval("option['label=test_option']/value")[0].content, \
+            "option_value")
+
+    def test_get_xml_no_parent(self):
+        field = Field(field_type = "text-single", \
+                      label = "Name", \
+                      var = "name", \
+                      value = "myaccount")
+        self.assertRaises(Exception, field.get_xml, None)
 
 class Option_TestCase(unittest.TestCase):
-    pass
+    def test_get_xml(self):
+        option = Option("test_option", "option_value")
+        xml_option = option.get_xml(None)
+        self.assertEquals(xml_option.prop("label"), "test_option")
+        self.assertEquals(xml_option.xpathEval("value")[0].content, \
+                          "option_value")
+