XML Schema Patterns for Databinding WG F2F

Agenda Bashing

<Yves> Yves: we can ask other developers (in the spec) a call for test results

<Yves> and if we should put such gathered results in our pages, we should flag them as contributed

pauld: if we have a call for logs, what process do we need to accept contributions?

<scribe> ACTION: ylafon to investigate IP and process about contribution of logs from third parties
[recorded in http://www.w3.org/2006/10/05-databinding-minutes.html#action101]

<trackbot> Created ACTION-67 - Investigate IP and process about contribution of logs from third parties [on Yves Lafon - due 2006-10-12].

Review of Outstanding Issues

pauld: we need text to explain ISSUE-37 etc that we may offer more than one pattern for a particular structure, eg absence of data, but we don't offer semantics or how to choose the best pattern on offer

ISSUE-20 Extension of Collections

pauld: useful versioning pattern based on xs:any

JonC: xs:any is Advanced

RESOLUTION: close ISSUE-20 as an Advanced Pattern

ISSUE-31 enumerated restriction types

pauld: DecimalEnumeration fails in Mono

JonC: what about the rest of them?

pauld: much the same for all of them in Mono, but many others work across the board. SOAP4r copes with them all.

RESOLUTION: close ISSUE-20 as Advanced

ISSUE-45 attribute use optional/required

pauld: do we have examples?

gcowe: we have AttributeRequired and AttributeOptional

pauld: works with tools i've looked at so far, that is schema-first

jon: will toolkits bounce invalid documents? If they do it's probably not an issue

pauld: Do tools prevent someone not sending it?

all: seems like a generic issue, but invalid behaviour is out of scope

pauld: we can accept this as a Basic pattern and pull it out following more testing

RESOLUTION: close ISSUE-45 as a Basic pattern

ISSUE-46 Fixed Attribute values

pauld: toolkits echo valid documents ok, but don't capture the fixed value in code

Yves: we need operations which do more work than echo, eg increment a number

pauld: it's a nice idea, but requires a different approach for each pattern, so not scalable

Yves: we should call for test code contributions

pauld: you still don't think 'echo' is good enough?

pauld: this smacks of ISSUE-28, what to do if the programming language doesn't fully support a data structure
... in this case initialising or fixing a string is available in most environments, but tools don't support it
... ISSUE-28 doesn't sit happily here, we closed this with no action:

" Discussion around this concluded that as long as the tools do not bail out and reject the schema and allow all valid instance docs to be processed and created (even if it allows invalid docs through) then we are happy for those structures to be included in Basic Patterns. The experience of the schema author is still good..."

pauld: in this case a Ruby developer has to look for the fixed value in the schema
... this reminds me of the constrain by a pattern, information is lost in code generation

JonC: good experience doesn't prevent the user from doing the right thing, but doesn't prevent you sending invalid data

Yves: you need -ve testing here

pauld: unconvinced we can test this 'black box' you have to look at the code
... we need introductory text for ISSUE-28
... under the rules of ISSUE-28 this should be Basic, but lack of fixed value in generated code make me want to set this as Advanced

gcowe: you need to include the behaviour of the source code

Yves: you are welcome to do more than echo
... seeing generated code in the test report is a requirement

pauld: i did this for SOAP4r as snippets.html, lets ask people to make sure they contribute evidence of their working along with a report of captured mesages

pauld: so ISSUE-28 is a floor for what makes a pattern Basic, I think we can still make value judgements on a case-by-case basis
... we need to make sure our text explains this
... i think in this case 'Fixed' is an Advanced pattern

gcowe: i think it's Basic

JonC: i think it's Basic

pauld: why do you want it basic?

JonC: nothing barfs

Yves: we could make it basic and rip it out after more testing

pauld: so in this case they generate the placeholder, just don't populate it and you think that's good enough
... OK we've just rehashed ISSUE-28
... I can live with either, so let's have our FIRST STRAW POLL!!!!

chad, question: options for ISSUE-46

chad, option 1: Basic pattern

chad, option 2: Advanced pattern

<pauld:> vote: 1,2

<pauld:> vote: 2,1

<Yves> vote: 1,2

<JonC> vote:1

<gcowe> vote: 1

chad, count

<chad> Question: options for ISSUE-46

<chad> Option 1: Basic pattern (3)

<chad> Option 2: Advanced pattern (1)

<chad> 4 voters: gcowe (1),JonC (1),pauld (2,1),Yves (1,2)

<chad> Round 1: Count of first place rankings.

<chad> Candidate 1 is elected.

<chad> Winner is option 1 - Basic pattern

RESOLUTION: close ISSSUE-46 as an Basic pattern

ISSUE-67 xsi:type

pauld: it works with some tools, but is a well known limitation of many other tools, e.g. ADB 1.0: http://ws.apache.org/axis2/1_0/adb/adb-howto.html

RESOLUTION: close ISSUE-67 as Advanced

ISSUE-58 anonymous complexType

JonC: we had this internally within BT but failed to work with BEA Weblogic 8.1

pauld: Paul Keil has this as being well supported. ISTR it not working well, do we need more evidence?
... very common pattern, do we want to do this?
... is that an easily fixed bug in one toolkit, or an indication of a widespread problem?
... it's not the end of the world for a pattern to be advanced

pauld: In our experience, venetian blind works well, but should we discount Russian Doll etc? We had that in ISSUE-18, schema authoring styles.

pauld: I'm attracted to the minium to declare victory, but it's always easier for us to take things out than add them in later

RESOLUTION: close ISSUE-58 as an Advanced pattern

LUNCH

ISSUE-64 Union of SimpleTypes

we have an example 'JeanSize'

pauld: can we think about making this based upon the pattern name?

RESOLUTION: close ISSUE-64 Union of simple types as an Advanced pattern

ISSUE-48 Local Elements defined by Reference

pauld: implicitly means global elements

works with toolkits AFAICT

JonC: it's how all doc/lit WSDLs work

RESOLUTION: close ISSUE-48 as a Basic pattern

ISSUE-60 Local Attributes defined by Reference

pauld: déjà vu with ISSUE-48!

RESOLUTION: close ISSUE-60 as a basic Pattern

ISSUE-56 simpleType resricted with min/max facets

pauld: introduces simpleTypes

JonC: chad! chad!

pauld: not like 'fixed'; value space of valid values greater than one
... explains why ISSUE-28 is a value judgement
... SOAP4r barfs at runtime

RESOLUTION: close ISSUE-56 as an Advanced pattern

ISSUE-68 xs:import of Schema 1.0 namespace

George sent mail: http://lists.w3.org/Archives/Public/public-xsd-databinding/2006Sep/0025

pauld: so not WS-I BP compliant, and of course we want to be compatible with the WS-I BP

pauld: OK, we need to consider if and how we reference the BP

pauld: How do we close this issue: Advanced or don't do it?

pauld: What's the use-case? I guess picking up a schema with this cruft in it?
... is it a problem for Advanced?

discussion of models of how WSDLs get built

JonC: we are in the Web services space, this isn't useful and not BP compliant

pauld: should I go to the BP and raise this as an issue?

pauld: OK mark it as Advanced for now, I'll engage the WS-I

<scribe> ACTION: pdowney to raise an issue on ISSUE-68 with the WS-I Basic Profile WG
[recorded in http://www.w3.org/2006/10/05-databinding-minutes.html#action102]

<trackbot> Created ACTION-68 - Raise an issue on ISSUE-68 with the WS-I Basic Profile WG [on Paul Downey - due 2006-10-12].

ISSUE-66 Enumeration based on a SimpleType

JonC: our example is based upon an Advanced pattern, so makes this Advanced?
... unless we come up with a simpler example
... does it make sense to have an enum of an enum?

pauld: or do we have other facets?
... if you're writing a schema you can do this in one type, Basic is for people authoring schemas in the main
... however Origo do this and it seems to work in their toolkits

gcowe: our use of this is possibly historical but it's pretty fundamental

RESOLUTION: close ISSUE-66 as an advanced pattern, needs more examples

ISSUE-15 Null datatype pattern as used by ASN.1 and others

pauld: split second pattern as ISSUE-70

RESOLUTION: close ISSUE-15 accepeted empty sequence as a Basic pattern

ISSUE-10 Mapping Element and Type names

pauld: the issue of death

http://www.w3.org/2002/ws/databinding/6/9/19-databinding-minutes.html#item01

pauld: walks through the history

Yves: for Advanced this is a must and can be easily implemented, comments for original names etc

pauld: proposal for way forward: split issue into concrete patterns for name formats, python rules, includes '-', Kanji set, etc and process them as business as usual

<scribe> ACTION: pdowney to build several examples based upon existing document for ISSUE-10
[recorded in http://www.w3.org/2006/10/05-databinding-minutes.html#action104]

<trackbot> Created ACTION-69 - Build several examples based upon existing document for ISSUE-10 [on Paul Downey - due 2006-10-12].

ISSUE-55 simple abstract substitutionGroup pattern

JonC: leave it open, we need a concrete example / pattern

pauld: We're closing issues. Examples follow as editorial work

RESOLUTION: close ISSUE-55 as Advanced, needs example

ISSUE-38 xs:any processContents value of 'skip'

gcowe: we have examples and patterns for this

RESOLUTION: close ISSUE-38 as Advanced

ISSUE-50 is xs:anyType an Advanced pattern?

pauld: well duh, it's commonly used but badly supported

RESOLUTION: close ISSUE-50 as an Advanced pattern

ISSUE-25 Map and Hash Patterns

pauld: this issue is a placeholder. We need to process each of the the concrete patterns and examples from the input document. I suspect they're all Advanced.

<scribe> ACTION: pdowney to explode concrete patterns for ISSUE-25 hash and map
[recorded in http://www.w3.org/2006/10/05-databinding-minutes.html#action106]

<trackbot> Created ACTION-70 - Explode concrete patterns for ISSUE-25 hash and map [on Paul Downey - due 2006-10-12].

ISSUE-17 Advice for representing a duration

pauld: we don't offer advice on which pattern to use, apart from grouping patterns. Duration is an Advanced datatype, leave it at that.

pauld: so do we accept xs:duration is OK for representing durations?

there is an awkward silence

RESOLUTION: close ISSUE-17 with no action

ISSUE-54 Sequence of choice Pattern

RESOLUTION: close ISSUE-54 as an Advanced pattern

ISSUE-59 attributeGroup pattern

RESOLUTION: close ISSUE-59 as an Advanced pattern

ISSUE-14 xs:default handling

RESOLUTION: accept ISSUE-14 as an Advanced pattern

ISSUE-2 Test Suite

discussion of tetsuite process

pauld: each toolkit is assigned an Id {toolkit}_{lang}_{version}, e.g.:

• soap4r_ruby_20051204
• mono_cs_1.1.13.8_osx
• etc

pauld: a toolkit specific genit script:

• generates a palatable examples.wsdl minus the examples which cause barfing:

  exclusions=$(echo "
  
      Union
      UnionSimpleDateString
      UnionDateString
      ...
  
  " | awk '{ printf ":%s:", $1}'|sed 's/::*/:/g')
  
  xsltproc  \
      --stringparam exclude $exclusions \
      $PATTERNS_DIR/examples2wsdl.xsl \
      $PATTERNS_DIR/examples.xml > examples.wsdl
  
  

• generates server code using the toolkit:

  ruby $SOAP4R_DIR/bin/wsdl2ruby.rb \
      --wsdl examples.wsdl \
      --type server --force
  

• implements the 'echo' server functions to simply return the request parameter, e.g.:

    def echoStringElement(echoStringElementRequest)
      raise NotImplementedError.new
    end
  

  is transformed into:

    def echoStringElement(echoStringElementRequest)
      return echoStringElementRequest
    end
  

• produces an HTML document of the implemented code snippets.html

  perl ... < default.rb > snippets.html
  

• deploys the service:

  ruby Service.rb
  

pauld: the generic runit script:

• takes our example soap 1.1 instance documents,
• fires them at the service
• writes request and response messages to a log file output.xml

pauld: People are welcome to pick this work up in the comfort of their own homes, though my Perl hacks might defeat some. Ideally the runit should be more shrink-wrapped - a jar and the sample soap files or as a Zip file, but that's work I've not got around to, yet

pauld: To get on the report all people have to do is contribute log files in the output.xml format, along with snippets.html

<Yves> ACTION: pdowney to publish logfile format
[recorded in http://www.w3.org/2006/10/05-databinding-minutes.html#action107]

<trackbot> Created ACTION-71 - Publish logfile format [on Paul Downey - due 2006-10-12].

pauld: we then use the log to generate a results.xml which checks the request versus response. This is where I got stuck.

pauld: Ajith suggested XMLUnit, which looks cool for the 95 case, but we still need hints for comparing floats etc

Yves: also useful if we have +1 test cases

pauld: I have an xslt to manufacture a Schematron schema from examples.xml which works well for comparing XPaths, e.g.

         <sch:assert 
	    test="xs:float(log:request/log:body/soap:Envelope/soap:Body/*/ex:floatElement) 
	= xs:float(log:response/log:body/soap:Envelope/soap:Body/*/ex:floatElement)">assertion 
	    "xs:float(ex:floatElement)" against FloatElement03 message 1 failed - mismatch
       <sch:assert>

pauld: but my XSLT isn't comparing full documents, only explicit XPaths. Just checking the response matches the request is our 95 case

Yves: XMLUnit looks interesting, especially the 'exact' then 'similar' match approach, I'd like to pick up this work

pauld: does a happy dance

pauld: that frees me up to work with George on generating my logs for Axis 1.x, XFire, gSOAP, etc, etc

ADJOURNED