Add plugin

(cherry picked from commit 2296d56)

sleekxmpp/plugins/xep_0122/data_validation.py

@@ -0,0 +1,19 @@
+from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.plugins.xep_0004 import stanza
+from sleekxmpp.plugins.xep_0004.stanza import FormField
+from sleekxmpp.plugins.xep_0122.stanza import FormValidation
+
+
+class XEP_0122(BasePlugin):
+    """
+    XEP-0004: Data Forms
+    """
+
+    name = 'xep_0122'
+    description = 'XEP-0122: Data Forms Validation'
+    dependencies = set(['xep_0004'])
+    stanza = stanza
+
+    def plugin_init(self):
+        register_stanza_plugin(FormField, FormValidation, iterable=True)

sleekxmpp/plugins/xep_0122/stanza.py

@@ -13,13 +13,17 @@ class FormValidation(ElementBase):
                 datatype='xs:dateTime'/>
       <value>2003-10-06T11:22:00-07:00</value>
     </field>
+
+    Questions:
+      Should this look at the datatype value and convert the range values as appropriate?
+      Should this stanza provide a pass/fail for a value from the field, or convert field value to datatype?
     """
 
     namespace = 'http://jabber.org/protocol/xdata-validate'
     name = 'validate'
     plugin_attrib = 'validate'
-    interfaces = set(('datatype', 'basic', 'open', 'range', 'regex', ))
+    interfaces = {'datatype', 'basic', 'open', 'range', 'regex', }
-    sub_interfaces = set(('basic', 'open', 'range', 'regex', ))
+    sub_interfaces = {'basic', 'open', 'range', 'regex', }
     plugin_attrib_map = {}
     plugin_tag_map = {}
 
@@ -33,22 +37,28 @@ class FormValidation(ElementBase):
         if value:
             self._add_field('basic')
         else:
-            self['basic'] = False
+            del self['basic']
 
     def set_open(self, value):
         if value:
             self._add_field('open')
+        else:
+            del self['open']
 
     def set_regex(self, regex):
         if regex:
             _regex = self._add_field('regex')
             _regex.text = regex
+        else:
+            del self['regex']
 
     def set_range(self, value, minimum=None, maximum=None):
         if value:
             _range = self._add_field('range')
             _range.attrib['min'] = str(minimum)
             _range.attrib['max'] = str(maximum)
+        else:
+            del self['range']
 
     def remove_all(self, except_tag=None):
         for a in self.sub_interfaces:
@@ -65,18 +75,20 @@ class FormValidation(ElementBase):
 
     def get_regex(self):
         present = self.xml.find('{%s}regex' % self.namespace)
-        if present:
+        if present is not None:
             return present.text
 
         return False
 
     def get_range(self):
-        present = self.xml.find('{%s}regex' % self.namespace)
+        present = self.xml.find('{%s}range' % self.namespace)
-        if present:
+        if present is not None:
-            return dict(present.attrib)
+            attributes = present.attrib
+            return_value = dict()
+            if 'min' in attributes:
+                return_value['minimum'] = attributes['min']
+            if 'max' in attributes:
+                return_value['maximum'] = attributes['max']
+            return return_value
 
         return False
-
-
-FormValidation.getBasic = FormValidation.get_basic
-FormValidation.setBasic = FormValidation.set_basic

tests/test_stanza_xep_0122.py

@@ -1,8 +1,7 @@
 import unittest
+
 from sleekxmpp import Message
 from sleekxmpp.test import SleekTest
-from sleekxmpp.thirdparty import OrderedDict
-
 import sleekxmpp.plugins.xep_0004 as xep_0004
 import sleekxmpp.plugins.xep_0122 as xep_0122
 from sleekxmpp.xmlstream import register_stanza_plugin
@@ -46,92 +45,113 @@ class TestDataForms(SleekTest):
           </message>
         """)
 
-    # def test_open_validation(self):
+        self.assertTrue(validation.get_basic())
-    #     """Testing using multiple instructions elements in a data form."""
+        self.assertFalse(validation.get_open())
-    #     msg = self.Message()
+        self.assertFalse(validation.get_range())
-    #     form = msg['form']
+        self.assertFalse(validation.get_regex())
-    #     field = form.addField(var='f1',
+
-    #                           ftype='text-single',
+    def test_open_validation(self):
-    #                           label='Text',
+        """Testing using multiple instructions elements in a data form."""
-    #                           desc='A text field',
+        msg = self.Message()
-    #                           required=True,
+        form = msg['form']
-    #                           value='Some text!')
+        field = form.addField(var='f1',
-    #
+                              ftype='text-single',
-    #     validation = field['validate']
+                              label='Text',
-    #     validation.set_open(True)
+                              desc='A text field',
-    #
+                              required=True,
-    #     self.check(msg, """
+                              value='Some text!')
-    #       <message>
+
-    #         <x xmlns="jabber:x:data" type="form">
+        validation = field['validate']
-    #           <field var="f1" type="text-single" label="Text">
+        validation.set_open(True)
-    #             <desc>A text field</desc>
+
-    #             <required />
+        self.check(msg, """
-    #             <value>Some text!</value>
+          <message>
-    #             <validate xmlns="http://jabber.org/protocol/xdata-validate">
+            <x xmlns="jabber:x:data" type="form">
-    #                 <open/>
+              <field var="f1" type="text-single" label="Text">
-    #             </validate>
+                <desc>A text field</desc>
-    #           </field>
+                <required />
-    #         </x>
+                <value>Some text!</value>
-    #       </message>
+                <validate xmlns="http://jabber.org/protocol/xdata-validate">
-    #     """)
+                    <open />
-    #
+                </validate>
-    # def test_regex_validation(self):
+              </field>
-    #     """Testing using multiple instructions elements in a data form."""
+            </x>
-    #     msg = self.Message()
+          </message>
-    #     form = msg['form']
+        """)
-    #     field = form.addField(var='f1',
+
-    #                           ftype='text-single',
+        self.assertFalse(validation.get_basic())
-    #                           label='Text',
+        self.assertTrue(validation.get_open())
-    #                           desc='A text field',
+        self.assertFalse(validation.get_range())
-    #                           required=True,
+        self.assertFalse(validation.get_regex())
-    #                           value='Some text!')
+
-    #
+    def test_regex_validation(self):
-    #     validation = field['validate']
+        """Testing using multiple instructions elements in a data form."""
-    #     validation.set_regex('[0-9]+')
+        msg = self.Message()
-    #
+        form = msg['form']
-    #     self.check(msg, """
+        field = form.addField(var='f1',
-    #       <message>
+                              ftype='text-single',
-    #         <x xmlns="jabber:x:data" type="form">
+                              label='Text',
-    #           <field var="f1" type="text-single" label="Text">
+                              desc='A text field',
-    #             <desc>A text field</desc>
+                              required=True,
-    #             <required />
+                              value='Some text!')
-    #             <value>Some text!</value>
+
-    #             <validate xmlns="http://jabber.org/protocol/xdata-validate">
+        regex_value = '[0-9]+'
-    #                 <regex>[0-9]+</regex>
+
-    #             </validate>
+        validation = field['validate']
-    #           </field>
+        validation.set_regex(regex_value)
-    #         </x>
+
-    #       </message>
+        self.check(msg, """
-    #     """)
+          <message>
-    #
+            <x xmlns="jabber:x:data" type="form">
-    # def test_range_validation(self):
+              <field var="f1" type="text-single" label="Text">
-    #     """Testing using multiple instructions elements in a data form."""
+                <desc>A text field</desc>
-    #     msg = self.Message()
+                <required />
-    #     form = msg['form']
+                <value>Some text!</value>
-    #     field = form.addField(var='f1',
+                <validate xmlns="http://jabber.org/protocol/xdata-validate">
-    #                           ftype='text-single',
+                    <regex>[0-9]+</regex>
-    #                           label='Text',
+                </validate>
-    #                           desc='A text field',
+              </field>
-    #                           required=True,
+            </x>
-    #                           value='Some text!')
+          </message>
-    #
+        """)
-    #     validation = field['validate']
+
-    #     validation.set_range(True, minimum=0, maximum=10)
+        self.assertFalse(validation.get_basic())
-    #
+        self.assertFalse(validation.get_open())
-    #     self.check(msg, """
+        self.assertFalse(validation.get_range())
-    #       <message>
+        self.assertTrue(validation.get_regex())
-    #         <x xmlns="jabber:x:data" type="form">
+
-    #           <field var="f1" type="text-single" label="Text">
+        self.assertEqual(regex_value, validation.get_regex())
-    #             <desc>A text field</desc>
+
-    #             <required />
+    def test_range_validation(self):
-    #             <value>Some text!</value>
+        """Testing using multiple instructions elements in a data form."""
-    #             <validate xmlns="http://jabber.org/protocol/xdata-validate">
+        msg = self.Message()
-    #                 <range min="0" max="10" />
+        form = msg['form']
-    #             </validate>
+        field = form.addField(var='f1',
-    #           </field>
+                              ftype='text-single',
-    #         </x>
+                              label='Text',
-    #       </message>
+                              desc='A text field',
-    #     """)
+                              required=True,
+                              value='Some text!')
+
+        validation = field['validate']
+        validation.set_range(True, minimum=0, maximum=10)
+
+        self.check(msg, """
+          <message>
+            <x xmlns="jabber:x:data" type="form">
+              <field var="f1" type="text-single" label="Text">
+                <desc>A text field</desc>
+                <required />
+                <value>Some text!</value>
+                <validate xmlns="http://jabber.org/protocol/xdata-validate">
+                    <range min="0" max="10" />
+                </validate>
+              </field>
+            </x>
+          </message>
+        """)
+
+        self.assertDictEqual(dict(minimum=str(0), maximum=str(10)), validation.get_range())
 
 
 suite = unittest.TestLoader().loadTestsFromTestCase(TestDataForms)