Copyright © @@ W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use, and software licensing rules apply.
This document draws on assertions found in the SOAP Version 1.2 specifications [SOAP Part1], [SOAP Part2], and provides a set of tests in order to show whether the assertions are implemented in a SOAP processor.
A SOAP 1.2 implementation that passes all of the tests specified in this document may claim to conform to the SOAP 1.2 Test Suite, @@ @@ @@. It is incorrect to claim to be compliant with the SOAP Version 1.2 specifications merely by passing successfully all the tests provided in this test suite. It is also incorrect to claim that an implementation is non complaint with the SOAP Version 1.2 specifications based on its failure to pass one or more of the tests in this test suite.
This document is an editors' copy that has no official standing.
| Editorial note: ASK | |
|
This document refers to SOAP 1.2 part 1 Editors SNAPSHOT
$Date: 2002/10/22 12:08:49 $ This document refers to SOAP 1.2 part 2 Editors SNAPSHOT $Date: 2002/10/22 12:08:49 $ | |
This section describes the status of this document at the time of its publication. Other documents may supersede this document. The latest status of this document series is maintained at the W3C.
This is the Last Call W3C Working Draft of the SOAP Version 1.2 Specification Assertions and Test Collection for review by by W3C members and other interested parties. It has been produced by the XML Protocol Working Group (WG), which is part of the Web Services Activity. This version is based on the @@ @@ @@ of the SOAP Version 1.2 Part 1 and Part 2 specifications. In the event of any discrepancy between the assertions in this document and Parts 1 and 2 of the specification, then the specification is considered to be authoritative.
The WG intends to publish this document as part of its eventual recommendation, to facilitate testing of SOAP implementations. In addition to soliciting feedback on its utility for that purpose, this document serves to identify the specific features of SOAP for which interoperable implementations will be shown prior to requesting Proposed Recommendation. The Working Group maintains a list of SOAP 1.2 implementations for the purpose of tracking implementation of these features.
Following completion of Last Call, the XML Protocol Working Group has agreed to advance the specification according to four exit criteria:
Sufficient reports of implementation experience have been gathered to demonstrate that SOAP processors based on the specification are implementable and have compatible behavior.
An implementation report shows that there are at least two different and interoperable implementations of every mandatory and optional feature.
Formal responses to all comments received by the Working Group.
If these criteria are met, the specification will advance to Proposed Recommendation. If the implementation exit criteria are not met then the specification will enter a Candidate Recommendation phase to ensure they are met.
A list of open Last Call issues against this document can be found at http://www.w3.org/2000/xp/Group/xmlp-lc-issues.
Comments on this document should be sent to xmlp-comments@w3.org (public archive [xmlp-comments archive]). It is inappropriate to send discussion email to this address. Comments should be sent during the last call review period, which ends 19 July 2002
Discussion of this document takes place on the public xml-dist-app@w3.org mailing list [distapp archive] under the email communication rules in the XML Protocol Working Group Charter [XMLP Charter].
Patent disclosures relevant to this specification may be found on the Working Group's patent disclosure page.
This is a public W3C Working Draft. It is a draft document and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite them as other than "works in progress". A list of all W3C technical reports can be found at http://www.w3.org/TR/.
1. Introduction
2. SOAP 1.2 Assertions
3. SOAP 1.2 Test Collection
4. References
A. Acknowledgements (Non-Normative)
B. Change Log (Non-Normative)
1. Introduction
2. SOAP 1.2 Assertions
2.1 SOAP 1.2, Part 1 Assertions
2.2 SOAP 1.2, Part 2 Assertions
3. SOAP 1.2 Test Collection
3.1 Introduction
3.2 Header Blocks Used by the Test Collection
3.2.1 echoOk
3.2.2 responseOk
3.2.3 Ignore
3.2.4 requiredHeader
3.2.5 DataHolder
3.2.6 concatAndForwardEchoOk
3.2.7 concatAndForwardEchoOkArg1
3.2.8 concatAndForwardEchoOkArg2
3.2.9 validateCountryCode
3.2.10 validateCountryCodeFault
3.2.11 echoResolvedRef
3.2.12 responseResolvedRef
3.3 Body Blocks Used by the Test Collection
3.3.1 echoOk
3.3.2 responseOk
3.3.3 echoHeader
3.3.4 echoHeaderResponse
3.4 RPC Methods/Procedures Used by the Test Collection
3.4.1 returnVoid
3.4.2 echoStruct
3.4.3 echoStructArray
3.4.4 echoStructAsSimpleTypes
3.4.5 echoStruct
3.4.6 echoNestedStruct
3.4.7 echoNestedArray
3.4.8 echoFloatArray
3.4.9 echoStringArray
3.4.10 echoIntegerArray
3.4.11 echoBase64
3.4.12 echoBoolean
3.4.13 echoDate
3.4.14 echoDecimal
3.4.15 echoFloat
3.4.16 echoString
3.4.17 countItems
3.4.18 echoBase64
3.5 Tests
4. References
4.1 Normative References
4.2 Informative References
A. Acknowledgements (Non-Normative)
B. Change Log (Non-Normative)
This document draws on assertions found in the SOAP Version 1.2 specifications, and provides a set of tests in order to show whether the assertions are implemented in a SOAP processor. The primary goal of this document is to foster interoperability between different SOAP 1.2 implementations. The document is intended to help implementors to write SOAP processors that comply with SOAP 1.2 specification, and interoperate with other SOAP processors that comply with SOAP 1.2 specification.
A SOAP 1.2 implementation that passes all of the tests specified in this document may claim to conform to the SOAP 1.2 Test Suite $Date @@/@@/@@ $.
Even though the purpose of the SOAP 1.2 Test Suite is to facilitate the creation of interoperable implementations, conformance to the SOAP 1.2 Test Suite does not imply conformance to the SOAP 1.2 specifications; there are mandatory requirements of the specifications that are not tested by the suite (as a simple example, SOAP 1.2 requires that every legal value of a role name is accepted, and all illegal ones rejected). An implementation may be said to be SOAP 1.2 conformant if and only if it it satisfies the conformance requirements specified in SOAP 1.2 specifications. The W3C does not at this time provide for any comprehensive means of testing for such conformance.
Similarly, an implementation may conform to the SOAP 1.2 specifications even if it does not support all capabilities tested by the SOAP 1.2 Test Suite. SOAP 1.2 specifications admits special purpose implementations, such as those in dedicated controllers, which may send and receive only a very limited suite of messages; the requirement is that whatever is done be done correctly. An implementation may conform to the SOAP 1.2 specifications even if it does not support all capabilities tested by the SOAP 1.2 Test Suite. The test suite defines higher level application semantics to enable testing and facilitate interoperable implementations. It is not necessary for a SOAP processor to support these higher level semantics to be SOAP 1.2 compliant.
Assertions for SOAP Version 1.2 Part 1 and Part 2 are numbered sequentially (1..n). "Location of the assertion" points the source of the assertion (section or subsection number) in Part 1 or Part 2. Hyperlinks are used to cross-reference to the original specification section/subsection.
Some of the tests in this document use SOAPBuilders interoperability tests as a started point, but have been modified to conform to the SOAP 1.2 specifications.
In particular, this document defines the following namespace names:
The SOAP envelope has the namespace name "http://www.w3.org/2002/06/soap-envelope" (see 5. SOAP Message Construct).
The SOAP Misunderstood element information item has the namespace name "http://www.w3.org/2002/06/soap-faults" (see 5.4.8 SOAP mustUnderstand Faults).
The SOAP Upgrade element information item has the namespace name "http://www.w3.org/2002/06/soap-upgrade" (see 5.4.7 VersionMismatch Faults).
Normative XML Schema [4], [5] documents for these namespace names can be found by dereferencing the namespace names above.
SOAP does not require that XML Schema processing (assessment or validation) be performed to establish the correctness or 'schema implied' values of element and attribute information items defined by this specification. The values associated with element and attribute information items defined in this specification MUST be carried explicitly in the transmitted SOAP message except where stated otherwise (see 5. SOAP Message Construct).
SOAP attribute information items have types described by XML Schema: Datatypes [5]. Unless otherwise stated, all lexical forms are supported for each such attribute, and lexical forms representing the same value in the XML Schema value space are considered equivalent for purposes of SOAP processing.
The roles assumed by a node MUST be invariant during the processing of an individual SOAP message.
This assertion cannot be fully tested, as a SOAP node is allowed to process and remove SOAP headers, reinsert them and send them upstream.
A SOAP header block MAY carry a role attribute information item (see 5.2.2 SOAP role Attribute) that is used to target the header block at SOAP nodes operating in the specified role. This specification refers to the value of the SOAP role attribute as the SOAP role for the corresponding SOAP header block.
A SOAP header block is said to be understood by a SOAP node if the software at that SOAP node has been written to fully conform to and implement the semantics conveyed by the combination of
local name and namespace name
[local name] and [namespace name]
of the outer-most element information item of that header block.
SOAP header blocks MAY carry mustUnderstand attribute information items (see 5.2.3 SOAP mustUnderstand Attribute). When the value of such an attribute information item is "true", the SOAP block is said to be mandatory.
Mandatory SOAP header blocks are presumed to somehow modify the semantics of other headers or body elements. Therefore, for every mandatory SOAP header block targeted to a node, that node MUST either process the header block or not process the SOAP message at all, and instead generate a fault (see 2.6 Processing SOAP Messages and 5.4 SOAP Fault).
This specification therefore does not require any fault to be generated based on the presence or value of the mustUnderstand attribute information item on a SOAP header block not targeted at the current processing node. In particular, it is not an error for an ultimate SOAP receiver to receive a message containing a mandatory header block that is targeted at a role other than the ones assumed by the ultimate SOAP receiver.
Unless otherwise stated, processing MUST be semantically equivalent to performing the following steps separately, and in the order given. Note however that nothing in this specification prevents the use of optimistic concurrency, roll back, or other techniques that might provide increased flexibility in processing order as long as all generated SOAP messages, SOAP faults and application-level side effects are equivalent to those that would be obtained by direct implementation of the following rules in the order shown below.
Determine the set of roles in which the node is to act. The contents of the SOAP envelope, including any SOAP header blocks and the SOAP body, MAY be inspected in making such determination.
Identify all header blocks targeted at the node that are mandatory.
If one or more of the SOAP header blocks identified in the preceding step are not understood by the node then generate a single SOAP fault with the
ValueofCodeset to "env:MustUnderstand" (see 5.4.8 SOAP mustUnderstand Faults). If such a fault is generated, any further processing MUST NOT be done. Faults relating to the contents of the SOAP body MUST NOT be generated in this step.Process all
mandatory
SOAP header blocks targeted at the node and, in the case of an ultimate SOAP receiver, the SOAP body.
A SOAP node MUST process all SOAP header blocks targeted at it. A SOAP node MAY choose to ignore the application level processing specified by non-mandatory SOAP header blocks targeted at it.
A SOAP node MAY also choose to process non-mandatory SOAP header blocks targeted at it.
In the case of a SOAP intermediary, and where the SOAP message exchange pattern and results of processing (e.g. no fault generated) require that the SOAP message be sent further along the SOAP message path, relay the message as described in section 2.7 Relaying SOAP Messages.
Header-related faults other than those related to understanding header blocks (see 2.4 Understanding SOAP Headers) MUST conform to the specification for the corresponding SOAP header block.
A message may contain or result in multiple errors during processing. Except where the order of detection is specifically indicated (as in 2.4 Understanding SOAP Header Blocks), a SOAP node is at liberty to reflect any single fault from the set of possible faults prescribed for the errors encountered. The selection of a fault need not be predicated on the application of the "MUST", "SHOULD" or "MAY" keywords to the generation of the fault, with the exception that if one or more of the prescribed faults is qualified with the "MUST" keyword, then any one fault from the set of possible faults MUST be generated.
Forwarding intermediaries MUST process the message according to the SOAP processing model defined in 2.6 Processing SOAP Messages. They MUST also remove from the message all SOAP header blocks targeted to them, prior to forwarding, regardless of whether these blocks were processed or ignored.
A SOAP node MAY support multiple envelope versions. However, when processing a message, a SOAP node MUST use the semantics defined by the version of that message.
If a SOAP node receives a message whose version is not supported it MUST generate a fault (see 5.4 SOAP Fault) with a Value of Code set to "env:VersionMismatch". Any other malformation of the message construct MUST result in the generation of a fault with a Value of Code set to "env:Sender".
Certain features might require end-to-end as opposed to hop-to-hop processing semantics. Although the SOAP Protocol Binding Framework allows end-to-end features to be expressed outside the SOAP envelope, no standard mechanism is provided for the processing by intermediaries of the resulting messages. A binding specification that expresses such features external to the SOAP envelope needs to define its own processing rules for those externally expressed features. A SOAP node is expected to conform to these processing rules (for example, describing what information is passed along with the SOAP message as it leaves the intermediary). The processing of SOAP envelopes in accordance with the SOAP Processing Model (see 2. SOAP Processing Model) MUST NOT be overridden by binding specifications.
The specification of a feature MUST include the following:
A URI used to name the feature. This enables the feature to be unambiguously referenced in description languages or during negotiation.
The information (state) required at each node to implement the feature.
The processing required at each node in order to fulfill the obligations of the feature including any handling of communication failures that might occur in the underlying protocol (see also 4.2 Binding Framework).
The information to be transmitted from node to node.
In the case of MEPs:
Any requirements to generate additional messages (such as responses to requests in a request/response MEP).
Rules for the delivery or other disposition of SOAP faults generated during the operation of the MEP.
The request-response MEP specified in SOAP 1.2 Part 2 [1] illustrates the specification of a MEP feature.
See 3.3 SOAP Message Exchange Patterns (MEPs) for additional requirements on MEP features.
A module specification follows the following rules. It:
The term 'SOAP Module' refers to the set of syntax and semantics associated with implementing a particular feature (see 3.1 SOAP Features) as SOAP header blocks. A Module is described in a Module Specification, which adheres to the following rules. It:
MUST identify itself with a URI. This enables the module to be unambiguously referenced in description languages or during negotiation.
MUST, if* the Module implements a Feature which has already been defined elsewhere, clearly refer to that Feature's URI. Note that a Module may EITHER explicitly refer to a separate Feature in this way OR may implicitly define a Feature simply by describing the semantics of the Module.
MUST clearly and completely specify the content and semantics of the SOAP header blocks used to implement the behavior in question, including if appropriate any modifications to the SOAP Processing model.
The SOAP extensibility model does not limit the extent to which SOAP can be extended. Nor does it prevent extensions from modifying the SOAP processing model from that described in 2. SOAP Processing Model
MAY utilize the property conventions defined in [SOAP Part2], section A Convention for Describing Features and Bindings, in describing the functionality that the module provides. If these conventions are followed, the module specification MUST clearly describe the relationship between the abstract properties and their representations in the SOAP envelope. Note that it is possible to write a feature specification purely in terms of abstract properties, and then write a separate module specification which implements that feature, mapping the properties defined in the feature specification to SOAP header blocks in the SOAP module.
MUST clearly specify any known interactions with or changes to the interpretation of the SOAP body. Furthermore, it MUST clearly specify any known interactions with or changes to the interpretation of other SOAP features (whether or not those features are themselves modules). For example, we can imagine a module which encrypts the SOAP body and inserts a SOAP header block containing a checksum and an indication of the encryption mechanism used. The specification for such a module would indicate that the decryption algorithm on the receiving side is to be run prior to any other modules which rely on the contents of the SOAP body.
The specification of a message exchange pattern MUST:
As mandated by 3.1.1 Requirements on Features provide a URI to name the MEP.
Describe the life cycle of a message exchange conforming to the pattern.
Describe the temporal/causal relationships, if any, of multiple messages exchanged in conformance with the pattern (e.g. responses follow requests and are sent to the originator of the request.)
Describe the normal and abnormal termination of a message exchange conforming to the pattern.
MEPs are SOAP features, so an MEP specification MUST conform to the requirements for SOAP feature specifications (see 3.1.1 Requirements on Features). An MEP specification MUST also include:
Any requirements to generate additional messages (such as responses to requests in a request/response MEP).
Rules for the delivery or other disposition of SOAP faults generated during the operation of the MEP.
In cases where multiple features are supported by a binding specification the specifications for those features MUST provide any information necessary for their successful use in combination. Similarly if a certain feature cannot be used if another feature is present this MUST be specified.
; this binding framework does not provide any explicit mechanism for ensuring such compatibility of multiple features.
In cases where multiple features are supported by a binding specification, the specifications for those features MUST provide any information necessary for their successful use in combination. Similarly, any dependencies of one feature on another (i.e. if successful use of one feature depends on use or non-use of another) MUST be specified. This binding framework does not provide any explicit mechanism for controlling the use of such interdependent features.
Therefore, the minimum responsibility of a binding in transmitting a message is to specify the means by which the SOAP XML Infoset is transferred to and reconstituted by the binding at the receiving SOAP node and to specify the manner in which the transmission of the envelope is effected using the facilities of the underlying protocol.
Section 5. SOAP Message Construct provides that the XML Infoset of a SOAP message MUST NOT include a DTD. Accordingly, a binding that uses the XML 1.0 serialization MUST NOT transmit a DTD; a binding that accepts XML 1.0 serializations MUST fault in a binding specific manner if an XML 1.0 serialization corresponding to a DTD for the SOAP message is received.
A SOAP message is specified as an XML Infoset that consists of a document information item with exactly one member in its [children] property, which MUST be the SOAP Envelope element information item (see 5.1 SOAP Envelope). This element information item is also the value of the [document element] property.
The XML infoset of a SOAP message MUST NOT contain a document type declaration information item.
A SOAP message SHOULD NOT contain processing instruction information items. A SOAP receiver MUST ignore processing instruction information items in SOAP messages that it receives.
SOAP messages sent by initial SOAP senders MUST NOT contain processing instruction information items. SOAP intermediaries MUST NOT insert processing instruction information items in SOAP messages they relay. SOAP receivers receiving a SOAP message containing a processing instruction information item SHOULD generate a SOAP fault with the
ValueofCodeset to "env:Sender". However, in the case where performance considerations make it impractical for an intermediary to detect processing instruction information items in a message to be relayed, the intermediary MAY leave such processing instruction information items unchanged in the relayed message.
Element information items defined by this specification may have zero or more character information item children whose character code is amongst the whitespace characters as defined by [8]. Unless otherwise indicated, such character information items are considered insignificant. A SOAP receiver MUST ignore such insignificant character information items.
The Envelope element information item has:
A [local name] of Envelope .
A [namespace name] of "http://www.w3.org/2002/06/soap-envelope".
Zero or more namespace qualified attribute information items amongst its [attributes] property.
One or two element information items in its [children] property in order as follows:
An optional Header element information item (see 5.2 SOAP Header).
A mandatory Body element information item (see 5.3 SOAP Body).
The encodingStyle attribute information item MAY only appear on:
A SOAP header block (see 5.2.1 SOAP header block).
A child element information item of the SOAP Body element information item (see 5.3.1 SOAP Body child Element).
A child element information item of the SOAP Detail element information item (see 5.4.5.1 SOAP detail entry).
Any descendent of 1, 2, and 3 above.
The scope of the encodingStyle attribute information item is that of its owner element information item and that element information item's descendants, unless a descendant itself carries such an attribute information item.
If no
encodingStyleattribute information item is in scope for a particular element information item or the value of such an attribute information item isthe zero-length URI ("")
"http://www.w3.org/2002/06/soap-envelope/encoding/none"
then no claims are made regarding the encoding style of that element information item and its descendants.
Each SOAP header block element information item:
MUST have a [namespace name] property which has a value, that is, MUST be namespace qualified.
MAY have any number of character information item children. Child character information items whose character code is amongst the whitespace characters as defined by [XML 1.0] are considered significant.
MAY have an
encodingStyleattribute information item in its [attributes] property.MAY have an
roleattribute information item in its [attributes] property.MAY have an
mustUnderstandattribute information item in its [attributes] property.MAY have any number of element information item children. Such element information items MAY be namespace qualified.
MAY have zero or more attribute information items in its [attributes] property. Among these MAY be any or all of the following, which have special significance for SOAP processing:
encodingStyleattribute information item (see 5.1.1 SOAP encodingStyle Attribute ).
roleattribute information item (see 5.2.2 SOAP role Attribute).
mustUnderstandattribute information item (see 5.2.3 SOAP mustUnderstand Attribute).
The SOAP header block attribute information items defined later in 5.2.2 SOAP role Attribute and 5.2.3 SOAP mustUnderstand Attribute affect the processing of SOAP messages by SOAP receivers (see 2. SOAP Processing Model). A SOAP sender generating a SOAP message SHOULD use these attributes only on SOAP header block. A SOAP receiver MUST ignore these attribute information items if they appear on descendants of a SOAP header block or on a SOAP body child element information item (or its descendents).
The role attribute information item has the following Infoset properties:
A [local name] of role .
A [namespace name] of "http://www.w3.org/2002/06/soap-envelope".
A [specified] property with a value of "true".
The type of the
roleattribute information item isanyURI in the namespace named "http://www.w3.org/2001/XMLSchema".
xs:anyURI.
The value of the
roleattribute information item is a URI that names a role that a SOAP node can assume.
The mustUnderstand attribute information item has the following Infoset properties:
A [local name] of mustUnderstand .
A [namespace name] of "http://www.w3.org/2002/06/soap-envelope".
A [specified] property with a value of "true".
The type of the
mustUnderstandattribute information item isboolean in the namespace "http://www.w3.org/2001/XMLSchema".
xs:boolean.
The Body element information item has:
A [local name] of Body .
A [namespace name] of "http://www.w3.org/2002/06/soap-envelope".
Zero or more namespace qualified attribute information items in its [attributes] property.
Zero or more namespace qualified element information items in its [children] property.
All child element information items of the SOAP
Bodyelement information item:
MUST have a [namespace name] property which has a value, that is, be namespace qualified.
MAY have an
encodingStyleattribute information item in their [attributes] property.MAY have any number of character information item children. Child character information items whose character code is amongst the whitespace characters as defined by [XML 1.0] are considered significant.
MAY have any number of element information item children. Such element information items MAY be namespace qualified.
MAY have zero or more attribute information items in its [attributes] property. Among these MAY be the following, which has special significance for SOAP processing:
encodingStyleattribute information item (see 5.1.1 SOAP encodingStyle Attribute).
The Fault element information item has:
A [local name] of Fault .
A [namespace name] of "http://www.w3.org/2002/06/soap-envelope".
Two or more child element information items in its [children] property in order as follows:
A mandatory Code element information item (see 5.4.1 SOAP Code Element).
A mandatory Reason element information item (see 5.4.2 SOAP Reason Element).
An optional Node element information item (see 5.4.3 SOAP Node Element).
An optional Role element information item (see 5.4.4 SOAP Role Element).
An optional Detail element information item (see 5.4.5 SOAP Detail Element).
The Code element information item has:
A [local name] of Code .
A [namespace name] of http://www.w3.org/2002/06/soap-envelope .
One or two child element information items in its [children] property, in order, as follows:
A mandatory Value element information item as described below (see 5.4.1.1 SOAP Value element (with Code parent))
An optional Subcode element information item as described below (see 5.4.1.2 SOAP Subcode element).
The Subcode element information item has:
A [local name] of Subcode .
A [namespace name] of http://www.w3.org/2002/06/soap-envelope .
One or two child element information items in its [children] property, in order, as follows:
A mandatory Value element information item as described below (see 5.4.1.3 SOAP Value element (with Subcode parent)).
An optional Subcode element information item (see 5.4.1.2 SOAP Subcode element).
The
Reasonelement information item has:
A [local name] of
Reason.A [namespace name] of
http://www.w3.org/2002/06/soap-envelope.An optional attribute information item with a [local name] of
langand [namespace name] of "http://www.w3.org/XML/1998/namespace" (see [XML 1.0], Language Identification).Any number of character information item children. Child character information items whose character code is amongst the whitespace characters as defined by [XML 1.0] are considered significant.
One or more
Textelement information item children (see 5.4.2.1 SOAP Text Element).
The
Textelement information item has:
A [local name] of
Text.A [namespace name] of
http://www.w3.org/2002/06/soap-envelope.A mandatory attribute information item with a [local name] of
langand [namespace name] of "http://www.w3.org/XML/1998/namespace" (see [XML 1.0], Language Identification).Any number of character information item children. Child character information items whose character code is amongst the whitespace characters as defined by [XML 1.0] are considered significant.
The Node element information item has:
A [local name] of Node .
A [namespace name] of http://www.w3.org/2002/06/soap-envelope .
SOAP nodes that do not act as the ultimate SOAP receiver MUST include this element information item.
The type of the
Nodeelement information item isanyURI in the "http://www.w3.org/2001/XMLSchema" namespace.
xs:anyURI.
/p>The
Roleelement information item has:
A [local name] of
Role.A [namespace name] of
http://www.w3.org/2002/06/soap-envelope.The type of the
Roleelement information item isanyURI in the "http://www.w3.org/2001/XMLSchema" namespace.
xs:anyURI.
The value of the
Roleelement information item MUST be one of the roles assumed by the node during processing of the message (see 2.2 SOAP Roles and SOAP Nodes).
The Detail element information item has:
A [local name] of Detail .
A [namespace name] of http://www.w3.org/2002/06/soap-envelope .
Zero or more attribute information items in its [attributes] property.
Zero or more child element information items in its [children] property.
The values of the
Valuechild element information item of theCodeelement information item are restricted to those in Table 2. Additional fault subcodes MAY be created for use by applications or features. Such subcodes are carried in theValuechild element information item of theSubcodeelement information item.The values of the
Valuechild element information item of theCodeelement information item are restricted to those defined by theenv:faultCodeEnumtype (see Table 2). Additional fault subcodes MAY be created for use by applications or features. Such subcodes are carried in theValuechild element information item of theSubcodeelement information item.
The
Upgradeelement information item has:
A [local name] of
Upgrade.A [namespace name] of "http://www.w3.org/2002/06/soap-upgrade".
One or more
envelope
Envelopeelement information items in its [children] property as described below:
The
envelope
Envelopeelement information item has:
A [local name] of
envelope
Envelope.
A [namespace name]
which has no value.
of "http://www.w3.org/2002/06/soap-upgrade".
An unqualified attribute information item with a local name of
qnamewhose type isQName in the "http://www.w3.org/2001/XMLSchema" namespace.
xs:QName.
A SOAP node MAY generate a SOAP fault for any one or more SOAP header blocks that were not understood in a SOAP message. It is NOT a requirement that the fault contain the qualified names of ALL such SOAP header blocks.
Each such header block element information item has:
A [local name] of
Misunderstood.A [local name] of
NotUnderstood.A [namespace name] of "http://www.w3.org/2002/06/soap-faults".
A
qnameattribute information item in its [attributes] property as described below.The
qnameattribute information item has the following Infoset properties:
A [local name] of
qname.A [namespace name] which has no value.
A [specified] property with a value of "true".
The type of the
qnameattribute information item isQName in the "http://www.w3.org/2001/XMLSchema" namespace.
xs:QName.
Its value is the XML qualified name of a SOAP header block which the faulting node failed to understand.
SOAP does not define a base URI but relies on the mechanisms defined in XML Base[11] and RFC 2396[6] for establishing a base URI against which relative URIs can be made absolute.
The use of IP addresses in URIs SHOULD be avoided whenever possible (see RFC 1900 [18]. However, when used, the literal format for IPv6 addresses in URIs as described by RFC 2732 [12] SHOULD be supported.
SOAP does not place any a priori limit on the length of a URI. Any SOAP node MUST be able to handle the length of any URI that it publishes and both SOAP senders and SOAP receivers SHOULD be able to deal with URIs of at least 2048 characters in length.
A SOAP/1.1 node receiving a SOAP Version 1.2 message will according to SOAP/1.1 generate a version mismatch SOAP fault based on a SOAP/1.1 message construct. That is, the envelope will have a
local name
[local name]
of
Envelopeand anamespace name
[namespace name]
of "http://schemas.xmlsoap.org/soap/envelope/".
A SOAP Version 1.2 node receiving a SOAP/1.1 message either:
MAY process the message as a SOAP/1.1 message (if supported), or
MUST generate a version mismatch SOAP fault based on a SOAP/1.1 message construct following SOAP/1.1 semantics. The SOAP fault SHOULD include an Upgrade header block as defined in this specification (see 5.4.7 VersionMismatch Faults) indicating support for SOAP Version 1.2. This allows a receiving SOAP/1.1 node to correctly interpret the SOAP fault generated by the SOAP Version 1.2 node.