Exemple #1
0
 def test_get_with_nested(self):
     """
     It is possible to access nested nodes.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     self.assertEqual("spam", foo.bar.egg)
Exemple #2
0
 def test_set_with_unknown_tag(self):
     """
     An error is raised when trying to set an attribute not in the schema.
     """
     schema = NodeSchema("foo")
     foo = schema.create()
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "egg")
     self.assertEqual("Unknown tag 'bar'", error.message)
Exemple #3
0
 def test_dump_with_missing_attribute(self):
     """
     L{NodeSchema.dump} ignores missing attributes if C{min_occurs} is zero.
     """
     schema = NodeSchema("foo")
     schema.add(LeafSchema("bar"), min_occurs=0)
     foo = NodeItem(schema)
     self.assertEqual("<foo/>", etree.tostring(schema.dump(foo)))
Exemple #4
0
 def test_set_with_unknown_tag(self):
     """
     An error is raised when trying to set an attribute not in the schema.
     """
     schema = NodeSchema("foo")
     foo = schema.create()
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "egg")
     self.assertEqual("Unknown tag 'bar'", error.message)
Exemple #5
0
 def test_dump_with_missing_attribute(self):
     """
     L{NodeSchema.dump} ignores missing attributes if C{min_occurs} is zero.
     """
     schema = NodeSchema("foo")
     schema.add(LeafSchema("bar"), min_occurs=0)
     foo = NodeItem(schema)
     self.assertEqual("<foo/>", etree.tostring(schema.dump(foo)))
Exemple #6
0
 def test_get_with_nested(self):
     """
     It is possible to access nested nodes.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     self.assertEqual("spam", foo.bar.egg)
Exemple #7
0
 def test_get_with_namespace(self):
     """
     The child leaf elements of a L{NodeItem} can be accessed as attributes.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo xmlns=\"spam\"><bar>egg</bar></foo>")
     foo = schema.create(root)
     self.assertEqual("egg", foo.bar)
Exemple #8
0
 def test_get_with_namespace(self):
     """
     The child leaf elements of a L{NodeItem} can be accessed as attributes.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo xmlns=\"spam\"><bar>egg</bar></foo>")
     foo = schema.create(root)
     self.assertEqual("egg", foo.bar)
Exemple #9
0
 def test_set_with_previous_child(self):
     """
     L{SequenceSchema.set} raises an error if the sequence has already
     a child.
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     error = self.assertRaises(RuntimeError, schema.set, NodeSchema("egg"))
     self.assertEqual("Sequence has already a child", str(error))
Exemple #10
0
 def test_get_with_reserved_keyword(self):
     """
     Attributes associated to tags named against required attributes can
     be accessed appending a '_' to the name.
     """
     schema = NodeSchema("foo", [LeafSchema("return")])
     root = etree.fromstring("<foo><return>true</return></foo>")
     foo = schema.create(root)
     self.assertEqual("true", foo.return_)
Exemple #11
0
 def test_get_with_non_required_tag(self):
     """
     No error is raised if a tag is missing and its min count is zero.
     """
     schema = NodeSchema("foo")
     schema.add(LeafSchema("bar"), min_occurs=0)
     root = etree.fromstring("<foo></foo>")
     foo = schema.create(root)
     self.assertIdentical(None, foo.bar)
Exemple #12
0
 def test_get_with_many_children(self):
     """
     Multiple children are supported.
     """
     schema = NodeSchema("foo", [LeafSchema("bar"), LeafSchema("egg")])
     root = etree.fromstring("<foo><bar>spam1</bar><egg>spam2</egg></foo>")
     foo = schema.create(root)
     self.assertEqual("spam1", foo.bar)
     self.assertEqual("spam2", foo.egg)
Exemple #13
0
 def test_dump(self):
     """
     L{NodeSchema.dump} creates an L{etree.Element} out of a L{NodeItem}.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     foo = NodeItem(schema)
     foo.bar = "spam"
     self.assertEqual("<foo><bar>spam</bar></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #14
0
 def test_get_with_non_required_tag(self):
     """
     No error is raised if a tag is missing and its min count is zero.
     """
     schema = NodeSchema("foo")
     schema.add(LeafSchema("bar"), min_occurs=0)
     root = etree.fromstring("<foo></foo>")
     foo = schema.create(root)
     self.assertIdentical(None, foo.bar)
Exemple #15
0
 def test_get_with_many_children(self):
     """
     Multiple children are supported.
     """
     schema = NodeSchema("foo", [LeafSchema("bar"), LeafSchema("egg")])
     root = etree.fromstring("<foo><bar>spam1</bar><egg>spam2</egg></foo>")
     foo = schema.create(root)
     self.assertEqual("spam1", foo.bar)
     self.assertEqual("spam2", foo.egg)
Exemple #16
0
 def test_get_with_reserved_keyword(self):
     """
     Attributes associated to tags named against required attributes can
     be accessed appending a '_' to the name.
     """
     schema = NodeSchema("foo", [LeafSchema("return")])
     root = etree.fromstring("<foo><return>true</return></foo>")
     foo = schema.create(root)
     self.assertEqual("true", foo.return_)
Exemple #17
0
 def test_dump(self):
     """
     L{NodeSchema.dump} creates an L{etree.Element} out of a L{NodeItem}.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     foo = NodeItem(schema)
     foo.bar = "spam"
     self.assertEqual("<foo><bar>spam</bar></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #18
0
 def test_get_with_missing_required_tag(self):
     """
     An error is raised when trying to access a required attribute and
     the associated tag is missing.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo></foo>")
     item = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, item, "bar")
     self.assertEqual("Missing tag 'bar'", error.message)
Exemple #19
0
 def test_get_with_unknown_tag(self):
     """
     An error is raised when trying to access an attribute not in the
     schema.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>egg</bar><spam>boom</spam></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, foo, "spam")
     self.assertEqual("Unknown tag 'spam'", error.message)
Exemple #20
0
 def test_get_with_missing_required_tag(self):
     """
     An error is raised when trying to access a required attribute and
     the associated tag is missing.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo></foo>")
     item = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, item, "bar")
     self.assertEqual("Missing tag 'bar'", error.message)
Exemple #21
0
 def test_get_with_empty_required_tag(self):
     """
     An error is raised if an expected required tag is found but has and
     empty value.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar/></foo>")
     item = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, item, "bar")
     self.assertEqual("Missing tag 'bar'", error.message)
Exemple #22
0
 def test_dump_with_multiple_children(self):
     """
     L{NodeSchema.dump} supports multiple children.
     """
     schema = NodeSchema("foo", [LeafSchema("bar"), LeafSchema("egg")])
     foo = NodeItem(schema)
     foo.bar = "spam1"
     foo.egg = "spam2"
     self.assertEqual("<foo><bar>spam1</bar><egg>spam2</egg></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #23
0
 def test_set_with_duplicate_tag(self):
     """
     An error is raised when trying to set an attribute associated
     with a tag that appears more than once.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>spam1</bar><bar>spam2</bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "egg")
     self.assertEqual("Duplicate tag 'bar'", error.message)
Exemple #24
0
 def test_set_with_required_tag(self):
     """
     An error is raised when trying to set a required attribute to C{None}.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>spam</bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", None)
     self.assertEqual("Missing tag 'bar'", error.message)
     self.assertEqual("spam", foo.bar)
Exemple #25
0
 def test_get_with_empty_required_tag(self):
     """
     An error is raised if an expected required tag is found but has and
     empty value.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar/></foo>")
     item = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, item, "bar")
     self.assertEqual("Missing tag 'bar'", error.message)
Exemple #26
0
 def test_set_with_non_leaf_tag(self):
     """
     An error is raised when trying to set a non-leaf attribute to
     a value other than C{None}.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "yo")
     self.assertEqual("Can't set non-leaf tag 'bar'", error.message)
Exemple #27
0
 def test_get_with_unknown_tag(self):
     """
     An error is raised when trying to access an attribute not in the
     schema.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>egg</bar><spam>boom</spam></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, getattr, foo, "spam")
     self.assertEqual("Unknown tag 'spam'", error.message)
Exemple #28
0
 def test_dump_with_multiple_children(self):
     """
     L{NodeSchema.dump} supports multiple children.
     """
     schema = NodeSchema("foo", [LeafSchema("bar"), LeafSchema("egg")])
     foo = NodeItem(schema)
     foo.bar = "spam1"
     foo.egg = "spam2"
     self.assertEqual("<foo><bar>spam1</bar><egg>spam2</egg></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #29
0
 def test_set_with_required_tag(self):
     """
     An error is raised when trying to set a required attribute to C{None}.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>spam</bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", None)
     self.assertEqual("Missing tag 'bar'", error.message)
     self.assertEqual("spam", foo.bar)
Exemple #30
0
 def test_set_with_non_leaf_tag(self):
     """
     An error is raised when trying to set a non-leaf attribute to
     a value other than C{None}.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "yo")
     self.assertEqual("Can't set non-leaf tag 'bar'", error.message)
Exemple #31
0
 def test_set_with_duplicate_tag(self):
     """
     An error is raised when trying to set an attribute associated
     with a tag that appears more than once.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<foo><bar>spam1</bar><bar>spam2</bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", "egg")
     self.assertEqual("Duplicate tag 'bar'", error.message)
Exemple #32
0
 def test_set_with_non_required_tag(self):
     """
     It is possible to set a non-required tag value to C{None}, in that
     case the element will be removed if present.
     """
     schema = NodeSchema("foo")
     schema.add(LeafSchema("bar"), min_occurs=0)
     root = etree.fromstring("<foo><bar>spam</bar></foo>")
     foo = schema.create(root)
     foo.bar = None
     self.assertEqual("<foo/>", etree.tostring(schema.dump(foo)))
Exemple #33
0
 def test_set_with_optional_node_tag(self):
     """
     It is possible to set an optional node tag to C{None}, in that
     case it will be removed from the tree.
     """
     schema = NodeSchema("foo")
     schema.add(NodeSchema("bar", [LeafSchema("egg")]), min_occurs=0)
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     foo.bar = None
     self.assertEqual("<foo/>", etree.tostring(schema.dump(foo)))
Exemple #34
0
 def test_set_with_required_non_leaf_tag(self):
     """
     An error is raised when trying to set a required non-leaf tag
     to C{None}.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", None)
     self.assertEqual("Missing tag 'bar'", error.message)
     self.assertTrue(hasattr(foo, "bar"))
Exemple #35
0
 def test_set_with_required_non_leaf_tag(self):
     """
     An error is raised when trying to set a required non-leaf tag
     to C{None}.
     """
     schema = NodeSchema("foo", [NodeSchema("bar", [LeafSchema("egg")])])
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, setattr, foo, "bar", None)
     self.assertEqual("Missing tag 'bar'", error.message)
     self.assertTrue(hasattr(foo, "bar"))
Exemple #36
0
 def test_get_with_non_required_nested(self):
     """
     It is possible to access a non-required nested node that has no
     associated element in the XML yet, in that case a new element is
     created for it.
     """
     schema = NodeSchema("foo")
     schema.add(NodeSchema("bar", [LeafSchema("egg")]), min_occurs=0)
     root = etree.fromstring("<foo/>")
     foo = schema.create(root)
     foo.bar.egg = "spam"
     self.assertEqual("<foo><bar><egg>spam</egg></bar></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #37
0
 def test_set_with_sequence_tag(self):
     """
     It is possible to set a sequence tag to C{None}, in that case
     all its children will be removed
     """
     schema = NodeSchema("foo")
     schema.add(SequenceSchema("bar",
                               NodeSchema("item", [LeafSchema("egg")])))
     root = etree.fromstring("<foo>"
                             "<bar><item><egg>spam</egg></item></bar><"
                             "/foo>")
     foo = schema.create(root)
     foo.bar = None
     self.assertEqual("<foo><bar/></foo>", etree.tostring(schema.dump(foo)))
Exemple #38
0
 def test_get_with_non_existing_index(self):
     """An error is raised when trying to access a non existing item."""
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<foo><item><bar>egg</bar></item></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, foo.__getitem__, 1)
     self.assertEqual("Non existing item in tag 'foo'", error.message)
Exemple #39
0
 def test_get(self):
     """
     The child elements of a L{SequenceItem} can be accessed as attributes.
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<foo><item><bar>egg</bar></item></foo>")
     foo = schema.create(root)
     self.assertEqual("egg", foo[0].bar)
Exemple #40
0
 def test_get_items(self):
     """L{SequenceItem} supports elements with many child items."""
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<foo>"
                             "<item><bar>egg0</bar></item>"
                             "<item><bar>egg1</bar></item>"
                             "</foo>")
     foo = schema.create(root)
     self.assertEqual("egg0", foo[0].bar)
     self.assertEqual("egg1", foo[1].bar)
Exemple #41
0
 def test_dump(self):
     """
     L{SequenceSchema.dump} creates a L{etree.Element} out of
     a L{SequenceItem}.
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     foo = SequenceItem(schema)
     foo.append().bar = "egg"
     self.assertEqual("<foo><item><bar>egg</bar></item></foo>",
                      etree.tostring(schema.dump(foo)))
Exemple #42
0
 def test_create_with_bad_tag(self):
     """
     L{SequenceSchema.create} raises an error if the tag of the given
     element doesn't match the expected one.
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<spam><item><bar>egg</bar></item></spam>")
     error = self.assertRaises(WSDLParseError, schema.create, root)
     self.assertEqual("Expected response with tag 'foo', but got "
                      "'spam' instead", error.args[0])
Exemple #43
0
 def test_add_with_invalid_min(self):
     """
     L{NodeSchema.add} allows the C{min_occurs} parameter to only be
     C{None}, zero or one.
     """
     schema = NodeSchema("foo")
     self.assertRaises(RuntimeError, schema.add, LeafSchema("bar"),
                       min_occurs=-1)
     self.assertRaises(RuntimeError, schema.add, LeafSchema("bar"),
                       min_occurs=2)
Exemple #44
0
 def test_iter(self):
     """L{SequenceItem} objects are iterable."""
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<foo>"
                             "<item><bar>egg0</bar></item>"
                             "<item><bar>egg1</bar></item>"
                             "</foo>")
     foo = schema.create(root)
     [item0, item1] = list(foo)
     self.assertEqual("egg0", item0.bar)
     self.assertEqual("egg1", item1.bar)
Exemple #45
0
 def test_remove_with_non_existing_item(self):
     """
     L{SequenceItem.remove} raises an exception when trying to remove a
     non existing item
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     root = etree.fromstring("<foo><item><bar>egg</bar></item></foo>")
     foo = schema.create(root)
     item = foo.remove(foo[0])
     error = self.assertRaises(WSDLParseError, foo.remove, item)
     self.assertEqual("Non existing item in tag 'foo'", error.message)
Exemple #46
0
 def test_create_with_bad_tag(self):
     """
     L{NodeSchema.create} raises an error if the tag of the given element
     doesn't match the expected one.
     """
     schema = NodeSchema("foo", [LeafSchema("bar")])
     root = etree.fromstring("<egg><bar>spam</bar></egg>")
     error = self.assertRaises(WSDLParseError, schema.create, root)
     self.assertEqual(
         "Expected response with tag 'foo', but got "
         "'egg' instead", error.message)
Exemple #47
0
 def test_append_with_too_many_items(self):
     """
     An error is raised when trying to append items above the max.
     """
     schema = SequenceSchema("foo")
     schema.set(NodeSchema("item", [LeafSchema("bar")]), min_occurs=0,
                max_occurs=1)
     root = etree.fromstring("<foo><item><bar>egg</bar></item></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, foo.append)
     self.assertEqual("Too many items in tag 'foo'", error.args[0])
     self.assertEqual(1, len(list(foo)))
Exemple #48
0
 def test_dump_with_many_items(self):
     """
     L{SequenceSchema.dump} supports many child items in the sequence.
     """
     schema = SequenceSchema("foo", NodeSchema("item", [LeafSchema("bar")]))
     foo = SequenceItem(schema)
     foo.append().bar = "spam0"
     foo.append().bar = "spam1"
     self.assertEqual(
         "<foo>"
         "<item><bar>spam0</bar></item>"
         "<item><bar>spam1</bar></item>"
         "</foo>", etree.tostring(schema.dump(foo)))
Exemple #49
0
 def test_delitem_with_not_enough_items(self):
     """
     L{SequenceItem.__delitem__} raises an error if trying to remove an item
     would make the sequence shorter than the required minimum.
     """
     schema = SequenceSchema("foo")
     schema.set(NodeSchema("item", [LeafSchema("bar")]), min_occurs=1,
                max_occurs=10)
     root = etree.fromstring("<foo><item><bar>egg</bar></item></foo>")
     foo = schema.create(root)
     error = self.assertRaises(WSDLParseError, foo.__delitem__, 0)
     self.assertEqual("Not enough items in tag 'foo'", error.args[0])
     self.assertEqual(1, len(list(foo)))
Exemple #50
0
 def test_set_with_optional_node_tag(self):
     """
     It is possible to set an optional node tag to C{None}, in that
     case it will be removed from the tree.
     """
     schema = NodeSchema("foo")
     schema.add(NodeSchema("bar", [LeafSchema("egg")]), min_occurs=0)
     root = etree.fromstring("<foo><bar><egg>spam</egg></bar></foo>")
     foo = schema.create(root)
     foo.bar = None
     self.assertEqual("<foo/>", etree.tostring(schema.dump(foo)))