<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 mono,
but 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, schema-first

jon: will toolkits bounce invalid
documents, probably not an issue

pauld: and will 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
Basic and pull it out following more testing

ISSUE-46 Fixed Attribute values

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

pauld: good approach, but
requires different approach for each pattern, not scalable

yves: we should call for test
code

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 -
snippits.html, lets ask people to make sure they contribute
working along with a report
... 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 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
... can live ewith either, let's have our FIRST STRAW
POLL!!!!

ISSUE-67 xsi:type

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 no the end of the world for a pattern to be
advanced
... our experience is venetian blind works well, but should we
discount Russian Doll etc? I'm attracted to the minium to
declare victory, but it's easier to take things out than add
them in later
... 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: deja-vu!

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

pauld: so not WS-I BP compliant,
and we want to be compatible with the WS-I BP
... OK, we need to think about a reference to the BP
... how do we close this issue? Advanced or don't do it?
... what's the use-case? maybe 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 but not BP compliant

pauld: do I go to the BP and
raise this as an issue?
... OK mark it as Advanced for now, I'll engaage the
WS-I

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 fundamental

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

pauld: genit generates palatable
examples.wsdl, generates code, implements functions, deploys,
runs service
... runit takes our example soap11 instance documents, fires
them at the service
... result is a log file 'output.xml' and a HTML document of
the implemented code 'snippits.html'
... we then need to generate a results.xml which checks the
request versus response
... Ajith suggests XMLUnit, 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: produced a Schematron
generator, but too heavyweight for just comparing documents

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