groovy/src/test/groovy/xml/NamespaceNodeTest.groovy

package groovy.xml

/**
 * Test the building of namespaced XML using GroovyMarkup
 */
class NamespaceNodeTest extends TestXmlSupport {

    void testTree_FAILS() {if (notYetImplemented()) return
        def builder = NodeBuilder.newInstance()
        def xmlns = new NamespaceBuilder(builder)

        def xsd = xmlns.namespace('http://www.w3.org/2001/XMLSchema', 'xsd')

        def root = xsd.schema(xmlns: ['foo': 'http://someOtherNamespace']) {
            annotation {
                documentation("Purchase order schema for Example.com.")
                //documentation(xmlns=[xml.lang:'en']) ["Purchase order schema for Example.com."]
            }
            element(name: 'purchaseOrder', type: 'PurchaseOrderType')
            element(name: 'comment', type: 'xsd:string')
            complexType(name: 'PurchaseOrderType') {
                sequence {
                    element(name: 'shipTo', type: 'USAddress')
                    element(name: 'billTo', type: 'USAddress')
                    element(minOccurs: '0', ref: 'comment')
                    element(name: 'items', type: 'Items')
                }
                attribute(name: 'orderDate', type: 'xsd:date')
            }
            complexType(name: 'USAddress') {
                sequence {
                    element(name: 'name', type: 'xsd:string')
                    element(name: 'street', type: 'xsd:string')
                    element(name: 'city', type: 'xsd:string')
                    element(name: 'state', type: 'xsd:string')
                    element(name: 'zip', type: 'xsd:decimal')
                }
                attribute(fixed: 'US', name: 'country', type: 'xsd:NMTOKEN')
            }
            complexType(name: 'Items') {
                sequence {
                    element(maxOccurs: 'unbounded', minOccurs: '0', name: 'item') {
                        complexType {
                            sequence {
                                element(name: 'productName', type: 'xsd:string')
                                element(name: 'quantity') {
                                    simpleType {
                                        restriction(base: 'xsd:positiveInteger') {
                                            maxExclusive(value: '100')
                                        }
                                    }
                                }
                                element(name: 'USPrice', type: 'xsd:decimal')
                                element(minOccurs: '0', ref: 'comment')
                                element(minOccurs: '0', name: 'shipDate', type: 'xsd:date')
                            }
                            attribute(name: 'partNum', type: 'SKU', use: 'required')
                        }
                    }
                }
            }
            /* Stock Keeping Unit, a code for identifying products */
            simpleType(name: 'SKU') {
                restriction(base: 'xsd:string') {
                    pattern(value: '\\d{3}-[A-Z]{2}')
                }
            }
        }
        assert root != null

        assertGPaths(root)
    }

    void assertGPaths(Node root) {
        Namespace xsd = new Namespace('http://www.w3.org/2001/XMLSchema', 'xsd')

        def children = root.children()
        println "has children $children"

        def name = root.name()
        println "name is of type ${name.getClass()} with value $name"

        root.children().each {println "has a child with name ${it.name()} and content $it"}

        def foo = xsd.annotation
        println "qname is $foo"
        println "qname url is $foo.namespaceURI"
        println "qname prefix is $foo.prefix"
        println "qname localPart is $foo.localPart"

        def a = root[xsd.annotation]
        println "Found results $a"

        def e = root[xsd.annotation][xsd.documentation]

        String text = e.text()
        println "Found element: $e with text: $text"
        assert text == "Purchase order schema for Example.com."
    }
}