Copyright 2013 by OASIS and Certain of its Members. All Rights Reserved.
| Test Assertion Analysis: | RSP8001 |
|---|---|
| General Notes: | This TA does not match any specific Rxxxx requirement. It is however verifying a general RSP requirement, and is intended to be used as prerequisite to other TAs. It allows other TAs to make abstraction of SOAP version, i.e. to assume an Envelope is always either SOAP 1.1 or 1.2. That way, {almost all) other TAs can be written in a more generic way. |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | RSP8001 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | (fn:namespace-uri-from-QName(fn:node-name(.)) = 'http://schemas.xmlsoap.org/soap/envelope/') |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2200 |
|---|---|
| General Notes: | . |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | RSP2200 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0001 |
|---|---|
| General Notes: | NOTE1: the actual test target is the observable artifact under test. NOTE2: given partial coverage, probably better to test for the negative case: predicate=true means failure. Inthe error message (or warning message): mention what to look for NOTE3: need to finalize the expected fault-message correlation. NOTE4: test env alignment: use same unrecognizable extension. |
| Coverage Assessment: | partial (only some extension cases, and some messages types to be tested, and also can't sort out the real cause of the Fault) |
| Target Type: | ENVELOPE |
| Test Target: | for a soap:Envelope (not just wsrm:CreateSequence) with a special extension that is known to be NOT understood |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there is a Fault in response to the message with extension. |
| Prescription: | mandatory |
| Reporting: | true=warning, false=undetermined |
| Test Control: | Align with unrecognizable extension expected in the TA. Generate a wsrm:CreateSequence message that makes use of the unrecognizable extension. Require response for anonymous URI. |
| Test Assertion: | RSP0001 |
|---|---|
| Description: | |
| Target: | some $elt in .//* satisfies string(fn:namespace-uri($elt)) = 'http://dummy.example.org/unknown/nmspace' ] |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0002a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: only checks for the common case of presence of an rm:Sequence header, for sequence traffic messages. |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0002a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0002b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: only checks for the common case of presence of an rm:Sequence header, for sequence traffic messages. |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0002b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0003 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0003 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1002a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP1002a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1002b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP1002b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2011a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2011a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2011b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2011b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2012 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2012 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2013 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial: |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2013 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP2014a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP2014b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOpBinding | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2005 |
|---|---|
| General Notes: | |
| Coverage Assessment: | good |
| Target Type: | ENVELOPE |
| Test Target: | for a soap:Envelope sent as a response (wsa:RelatesTo) to another Envelope sent over an HTTP response |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The target Envelope is sent over an HTTP Request |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2005 |
|---|---|
| Description: | |
| Target: | some $reqm in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope satisfies $reqm/*:Header/wsa:MessageID = ./*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] and $reqm/../../@type = 'response' ] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0010 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | No fault is sent back by the CS receiver. |
| Prescription: | mandatory |
| Reporting: | true=warning, false=undetermined |
| Test Control: | Warning: apparent failure. Verify if the Fault has not other causes. |
| Test Assertion: | RSP0010 |
|---|---|
| Description: | |
| Target: | *:Body/wsrm:CreateSequence[not(wsrm:Offer)]] |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0011 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | No fault is sent back by the CS receiver. |
| Prescription: | mandatory |
| Reporting: | true=warning, false=undetermined |
| Test Control: | Warning: apparent failure. Verify if the Fault has not other causes. |
| Test Assertion: | RSP0011 |
|---|---|
| Description: | |
| Target: | |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[not (@RelationshipType) or ( @RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' ) ] = $target/*:Header/wsa:MessageID) ]/wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0120 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE (with RM header) |
| Test Target: | For any envelope with RM header, for which there exists at least one preceeding envelope in the log with RM header featuring same wsrm:Identifier and wsrm:MessageNumber elements, |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | either the target envelope has no wsa:MessageID and every sibling envelope does not have one, or the target envelope has wsa:MessageID and every sibling envelope has the same. |
| Prescription: | mandatory |
| Reporting: | (default: true=pass, false=fail) |
| Test Control: | MIM config: Generate message resending - e.g. by blocking Acks, or blocking the regular messages. |
| Test Assertion: | RSP0120 |
|---|---|
| Description: | |
| Target: | *:Header/wsrm:Sequence = preceding::*:Envelope/*:Header/wsrm:Sequence] |
| Predicate: | every $prevenv in preceding::*:Envelope[*:Header/wsrm:Sequence = $curenv/*:Header/wsrm:Sequence] satisfies ((not($prevenv/*:Header/wsa:MessageID) and not($curenv/*:Header/wsa:MessageID)) or $prevenv/*:Header/wsa:MessageID = $curenv/*:Header/wsa:MessageID ) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0210 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE (either CS or TS) |
| Test Target: | For a soap:Envelope with either a wsrm:CloseSequence or a wsrm:TerminateSequence element in the soap:Body |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | the Envelope also contains wsrm:LastMsgNumber: proposed XPath= se:Body/wsrm:*/wsrm:LastMsgNumber |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: | Generate either a wsrm:CloseSequence message, or a wsrm:TerminateSequence |
| Test Assertion: | RSP0210 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0400a |
|---|---|
| General Notes: | NOTE1: needs artificial traffic generation to stimulate fault; if then easy, might need to use signature of corruption and correlation to fault or lack thereof.NOTE2: Test env. can cause a fault situation for one of the RM protocol mesg, and then we must observe a correlating Fault in the log. NOTE3: TA will only test some of the faulty cases (partial coverage) |
| Coverage Assessment: | partial, due to lack of exhaustive coverage of cases. |
| Target Type: | ENVELOPE (of RM protocol message) |
| Test Target: | For a faulty RM protocol message above (based on predefined test control protocol) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | There is a related Fault message in response, in the log. |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: | Generate a faulty RM protocol message, or using MIM corrupt a correctly generated one. |
| Test Assertion: | RSP0400a |
|---|---|
| Description: | |
| Target: | *:Body/wsrm:CloseSequence or *:Body/wsrm:TerminateSequence or *:Header/wsrm:AckRequested] [some $id in .//wsrm:Identifier satisfies fn:contains($id, 'http://dummy.example.org/unknown/nmspace')] |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0400b |
|---|---|
| General Notes: | NOTE1: needs artificial traffic generation to stimulate fault; if then easy, might need to use signature of corruption and correlation to fault or lack thereof.NOTE2: Test env. can cause a fault situation for one of the RM protocol mesg, and then we must observe a correlating Fault in the log. NOTE3: TA will only test some of the faulty cases (partial coverage) |
| Coverage Assessment: | partial, due to lack of exhaustive coverage of cases. |
| Target Type: | ENVELOPE (of RM protocol message) |
| Test Target: | For a faulty RM protocol message above (based on predefined test control protocol) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | There is a related Fault message in response, in the log. |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: | Generate a faulty RM protocol message, or using MIM corrupt a correctly generated one. |
| Test Assertion: | RSP0400b |
|---|---|
| Description: | |
| Target: | *:Body/wsrm:CloseSequence or *:Body/wsrm:TerminateSequence or *:Header/wsrm:AckRequested] [some $id in .//wsrm:Identifier satisfies fn:contains($id, 'http://dummy.example.org/unknown/nmspace')] |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0500 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: |
| Test Assertion: | RSP0500 |
|---|---|
| Description: | |
| Target: | [ *:Header[wsrm:SequenceAcknowledgement and not(*:Header/wsse:Security//xenc:ReferenceList) and wsa:To] and *:Body[node() and not(*:Fault) and not(wsrm:*)]] [ some $tgt in . satisfies some $csr in /wsil:testLog/wsil:messageLog/wsil:message//*:Envelope[*:Body/wsrm:CreateSequenceResponse][$tgt/*:Header/wsrm:SequenceAcknowledgement/wsrm:Identifier = *:Body/wsrm:CreateSequenceResponse/wsrm:Identifier] satisfies some $cs in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Body/wsrm:CreateSequence] satisfies ($csr/../../@conversation = $cs/../../@conversation or $csr/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $cs/*:Header/wsa:MessageID)] |
| co-Target: mycreateseq | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0530a |
|---|---|
| General Notes: | The trick to testing this requirement is to define an response operation with an empty body and a non-empty wsa:Action header and create a situation in which this response is likely to carry a piggybacked acknowledgement. Case 1: a wsa:Action is defined in the WSDL for an empty response. Case 2: not so -- default in 3.3 apples. |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope which: a. Corresponds to the wsdl:output message of our test scenario (i.e. is the response to the wsdl:input message in the test scenario). b. Has one or more SequenceAcknowledgment headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of the wsa:Action header is as defined by wsam:Action attribute of the wsdl:output message in the test scenario |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: | (additional scenarios) Scenario: x.x.x Reliable_Request_Empty_Response Create a WSDL with a portType that defines a single request-response operation. The wsdl:output of this operation should have an empty message and a non-empty wsam:Action attribute. A client implementation of this WSDL reliably sends the request messages and either reliably or non-reliably receives the response messages. So two cases are looked at: considering an empty out message with SeqAck piggybacked: (1) if non-empty wsam:Action in WSDL for the out message, then a wsa:Action with same value should be in header, (2) if no wsam:Action in WSDL for the out message, then a wsa:Action with default 'SeqAck' value should be in. |
| Test Assertion: | RSP0530a |
|---|---|
| Description: | |
| Target: | [ *:Header[wsrm:SequenceAcknowledgement and not(//xenc:ReferenceList)] and *:Body[ not(*:Fault) and not(wsrm:*)]/* and ( *:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope/*:Header/wsa:MessageID) ] |
| co-Target: myOpBind | [ some $opb in . satisfies some $req in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[ *:Header/wsa:ReplyTo or ./../../@type = 'request' ] satisfies ($target/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $req/*:Header/wsa:MessageID) and ( $opb/@name = local-name-from-QName(node-name($req/*:Body/*[1])) or (some $pop in //wsil:descriptionFile/wsdl:definitions/wsdl:portType/wsdl:operation[@name = $opb/@name] satisfies some $dmsg in $pop/../../wsdl:message[fn:resolve-QName(xsd:string(wsdl:part[1]/@element), .) = fn:node-name($req/*:Body/*[1])] satisfies fn:ends-with($pop/wsdl:input/@message, $dmsg/@name) ) ) ][1] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0530b |
|---|---|
| General Notes: | The trick to testing this requirement is to define an response operation with an empty body and a non-empty wsa:Action header and create a situation in which this response is likely to carry a piggybacked acknowledgement. Case 1: a wsa:Action is defined in the WSDL for an empty response. Case 2: not so -- default in 3.3 apples. |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope which: a. Corresponds to the wsdl:output message of our test scenario (i.e. is the response to the wsdl:input message in the test scenario). b. Has one or more SequenceAcknowledgment headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of the wsa:Action header is as defined by wsam:Action attribute of the wsdl:output message in the test scenario |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | (additional scenarios) Scenario: x.x.x Reliable_Request_Empty_Response Create a WSDL with a portType that defines a single request-response operation. The wsdl:output of this operation should have an empty message and a non-empty wsam:Action attribute. A client implementation of this WSDL reliably sends the request messages and either reliably or non-reliably receives the response messages. So two cases are looked at: considering an empty out message with SeqAck piggybacked: (1) if non-empty wsam:Action in WSDL for the out message, then a wsa:Action with same value should be in header, (2) if no wsam:Action in WSDL for the out message, then a wsa:Action with default 'SeqAck' value should be in. |
| Test Assertion: | RSP0530b |
|---|---|
| Description: | |
| Target: | [ *:Header[wsrm:SequenceAcknowledgement and not(//xenc:ReferenceList)] and *:Body[element() and not(wsmc:MakeConnection) and not(*:Fault) and not(wsrm:*)] and not(*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]) ] |
| co-Target: myOpBind | [ some $opb in . satisfies ( $opb/@name = local-name-from-QName(node-name($target/*:Body/*[1])) or (some $pop in //wsil:descriptionFile/wsdl:definitions/wsdl:portType/wsdl:operation[@name = $opb/@name] satisfies some $dmsg in $pop/../../wsdl:message[fn:resolve-QName(xsd:string(wsdl:part[1]/@element), .) = fn:node-name($target/*:Body/*[1])] satisfies fn:ends-with($pop/wsdl:input/@message, $dmsg/@name)) ) ][1] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0530c |
|---|---|
| General Notes: | The trick to testing this requirement is to define an response operation with an empty body and a non-empty wsa:Action header and create a situation in which this response is likely to carry a piggybacked acknowledgement. Case 1: a wsa:Action is defined in the WSDL for an empty response. Case 2: not so -- default in 3.3 apples. |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope which: a. Corresponds to the wsdl:output message of our test scenario (i.e. is the response to the wsdl:input message in the test scenario). b. Has one or more SequenceAcknowledgment headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of the wsa:Action header is as defined by wsam:Action attribute of the wsdl:output message in the test scenario |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | (additional scenarios) Scenario: x.x.x Reliable_Request_Empty_Response Create a WSDL with a portType that defines a single request-response operation. The wsdl:output of this operation should have an empty message and a non-empty wsam:Action attribute. A client implementation of this WSDL reliably sends the request messages and either reliably or non-reliably receives the response messages. So two cases are looked at: considering an empty out message with SeqAck piggybacked: (1) if non-empty wsam:Action in WSDL for the out message, then a wsa:Action with same value should be in header, (2) if no wsam:Action in WSDL for the out message, then a wsa:Action with default 'SeqAck' value should be in. |
| Test Assertion: | RSP0530c |
|---|---|
| Description: | |
| Target: | [ *:Header/wsrm:SequenceAcknowledgement and not(*:Body/* ) and not(*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]) ] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0530d |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope with: a. MakeConnection: b. Has one or more SequenceAcknowledgment headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of the wsa:Action header is the MC URI. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0530d |
|---|---|
| Description: | |
| Target: | [ *:Header/wsrm:SequenceAcknowledgement and *:Body/wsmc:MakeConnection ] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0600 |
|---|---|
| General Notes: | NOTE1: only a recommendation. TA will be useful to assess the behavior of implementations, if not to assess conformance. NOTE2: no requirement the response sequence is resulting from an offer? |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE (with RM header) |
| Test Target: | For an Envelope E1b that is sent reliably in response to another Envelope E1a sent reliably, if there exists an Envelope E2b that is sent reliably in response to another Envelope E2a sent reliably in the same sequence as E1a. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | every Envelope E2b matching the context has same wsrm:Identifier as E1b. |
| Prescription: | preferred |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP0600 |
|---|---|
| Description: | |
| Target: | [.//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] and .//*:Header/wsrm:Sequence] [some $resp1 in . satisfies some $req1 in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[(.//*:Header/wsa:MessageID = $resp1//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]) and .//*:Header/wsrm:Sequence] satisfies (.//*:Header/wsrm:Sequence/wsrm:Identifier = $req1//*:Header/wsrm:Sequence/wsrm:Identifier) and (.//*:Header/wsa:ReplyTo/wsa:Address = $req1//*:Header/wsa:ReplyTo//wsa:Address or (not(.//*:Header/wsa:ReplyTo) and not($req1//*:Header/wsa:ReplyTo)) )] |
| co-Target: siblingresp | [.//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] and .//*:Header/wsrm:Sequence] [ some $resp2 in . satisfies some $req2 in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[(.//*:Header/wsa:MessageID = $resp2//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] )] satisfies some $req1 in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[.//*:Header/wsrm:Sequence/wsrm:Identifier = $req2//*:Header/wsrm:Sequence/wsrm:Identifier] satisfies ($req1//*:Header/wsa:MessageID = $target//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]) ] [fn:last()] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | preferred |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0610 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0610 |
|---|---|
| Description: | |
| Target: | [@type = 'request' and .//*:Header/wsrm:Sequence] [some $req1 in . satisfies $req1/preceding::wsil:message[@type = 'request' and (.//*:Header/wsrm:Sequence/wsrm:Identifier = $req1//*:Header/wsrm:Sequence/wsrm:Identifier) and ( ( not(.//*:Header/wsa:ReplyTo) and $req1//*:Header/wsa:ReplyTo and not(fn:contains(xsd:string($req1//*:Header/wsa:ReplyTo[1]/wsa:Address), 'anonymous'))) or ( not($req1//*:Header/wsa:ReplyTo) and .//*:Header/wsa:ReplyTo and not(fn:contains(xsd:string(.//*:Header/wsa:ReplyTo[1]/wsa:Address), 'anonymous'))) or ( $req1//*:Header/wsa:ReplyTo and .//*:Header/wsa:ReplyTo and ( not(.//*:Header/wsa:ReplyTo/wsa:Address = $req1//*:Header/wsa:ReplyTo/wsa:Address) or not(.//*:Header/wsa:ReplyTo/wsa:ReferenceParameters = $req1//*:Header/wsa:ReplyTo/wsa:ReferenceParameters) )) ) ] ] |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target//*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2004a |
|---|---|
| General Notes: | When the wsa:ReplyTo addressing property of a request message (SOAP envelope included in the HTTP entity body of the HTTP request) described by the input message of a WSDL request-response operation is set to a MakeConnection anonymous URI, the corresponding response MESSAGE (SOAP envelope included in the HTTP entity body of the HTTP response) described by the WSDL output message of the same WSDL request-response operation MUST be sent as an HTTP response to either the HTTP request that carried the WSDL input message, or to the HTTP request that carried a wsmc:MakeConnection message with the correct MakeConnection anonymous URI. |
| Coverage Assessment: | Good |
| Target Type: | MESSAGE |
| Test Target: | response message to a MakeConnection that has an MC anon ReplyTo |
| Test co-Target(s): | related request-response WSDL op |
| Test Prerequisite: | |
| Predicate: | response message is sent on same HTTP connection (response), or is sent on another HTTP response of a MakeConnection request with same MC URI in wsmc:Address. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2004a |
|---|---|
| Description: | |
| Target: | [.//*:Envelope[*:Header/wsa:RelatesTo and not(*:Header/wsse:Security//xenc:ReferenceList) and not(*:Body/*:Fault) and not(*:Body/wsrm:*)]] [ some $resp1 in . satisfies some $req1 in /wsil:testLog/wsil:messageLog/wsil:message[.//*:Header/wsa:MessageID = $resp1//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]] satisfies /wsil:testLog/wsil:descriptionFiles/wsil:descriptionFile/wsdl:definitions/wsdl:binding[.//*[@style = 'rpc']]/wsdl:operation[wsdl:input and wsdl:output][@name = fn:local-name-from-QName(node-name($req1//*:Body/*[1]))]) |
| co-Target: myRequestMsg | [.//*:Header/wsa:MessageID = $target//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] and not (./wsil:messageContents/*:Envelope/*:Body/wsmc:MakeConnection )] |
| co-Target: myOpBinding | |
| Predicate: | (some $req2 in /wsil:testLog/wsil:messageLog/wsil:message[@type = 'request' and @conversation = $target/@conversation] satisfies |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2004b |
|---|---|
| General Notes: | When the wsa:ReplyTo addressing property of a request message (SOAP envelope included in the HTTP entity body of the HTTP request) described by the input message of a WSDL request-response operation is set to a MakeConnection anonymous URI, the corresponding response MESSAGE (SOAP envelope included in the HTTP entity body of the HTTP response) described by the WSDL output message of the same WSDL request-response operation MUST be sent as an HTTP response to either the HTTP request that carried the WSDL input message, or to the HTTP request that carried a wsmc:MakeConnection message with the correct MakeConnection anonymous URI. |
| Coverage Assessment: | Good |
| Target Type: | MESSAGE |
| Test Target: | response message to a MakeConnection that has an MC anon ReplyTo |
| Test co-Target(s): | related request-response WSDL op |
| Test Prerequisite: | |
| Predicate: | response message is sent on same HTTP connection (response), or is sent on another HTTP response of a MakeConnection request with same MC URI in wsmc:Address. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2004b |
|---|---|
| Description: | |
| Target: | [.//*:Envelope[*:Header/wsa:RelatesTo and not(*:Header/wsse:Security//xenc:ReferenceList) and not(*:Body/*:Fault) and not(*:Body/wsrm:*)]] [ some $resp1 in . satisfies some $req1 in /wsil:testLog/wsil:messageLog/wsil:message[.//*:Header/wsa:MessageID = $resp1//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]] satisfies /wsil:testLog/wsil:descriptionFiles/wsil:descriptionFile/wsdl:definitions/wsdl:message[fn:resolve-QName(xsd:string(wsdl:part[1]/@element), . ) = fn:node-name($req1//*:Envelope/*:Body/*[1])]) |
| co-Target: myRequestMsg | [.//*:Header/wsa:MessageID = $target//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] and not (./wsil:messageContents/*:Envelope/*:Body/wsmc:MakeConnection )] |
| co-Target: myOpBinding | [wsdl:input and wsdl:output] [ some $opBinding in . satisfies some $dmesg in /wsil:testLog/wsil:descriptionFiles/wsil:descriptionFile/wsdl:definitions/wsdl:message[wsdl:part[fn:resolve-QName(xsd:string(@element), . ) = fn:node-name($myRequestMsg//*:Envelope/*:Body/*[1])] ] satisfies $opBinding/@name = $dopmsg/../@name |
| Predicate: | (some $req2 in /wsil:testLog/wsil:messageLog/wsil:message[@type = 'request' and @conversation = $target/@conversation] satisfies |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2030 |
|---|---|
| General Notes: | . |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with s:Body/MC and wsa:Action header |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | wsa:Action value is http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP2030 |
|---|---|
| Description: | |
| Target: | [*:Body/wsmc:MakeConnection and *:Header/wsa:Action] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2031 |
|---|---|
| General Notes: | If a MESSAGE contains a SOAP 1.1 envelope with the wsmc:MakeConnection element as the child of the Body, the HTTP SOAPAction header, if present and not equal to the value of "" (empty string), MUST contain the value "http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection. |
| Coverage Assessment: | Good |
| Target Type: | MESSAGE |
| Test Target: | For a Message with sopa11:Body/MC and HTTP SOAPAction header |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | either SOAPAction value isempty string, or "http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection" |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP2031 |
|---|---|
| Description: | |
| Target: | [wsil:messageContents/soap11:Envelope/soap11:Body/wsmc:MakeConnection and (some $ky in wsil:httpHeaders/wsil:httpHeader/@key satisfies fn:lower-case($ky) = 'soapaction' )] |
| Predicate: | or wsil:httpHeaders/wsil:httpHeader[fn:lower-case(@key) = 'soapaction']/@value = '' ) not (wsil:httpHeaders/wsil:httpHeader[fn:lower-case(@key) = 'soapaction']/@quoted )) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2032 |
|---|---|
| General Notes: | If a MESSAGE contains a SOAP 1.2 envelope with the wsmc:MakeConnection element as the child of the Body, the action parameter of the HTTP Content-Type header, if present, MUST contain the value "http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection" |
| Coverage Assessment: | Good |
| Target Type: | MESSAGE |
| Test Target: | For an Message with sopa12:Body/MC and action parameter of the HTTP Content-Type header |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | action parameter = "http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection" |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP2032 |
|---|---|
| Description: | |
| Target: | [wsil:messageContents/soap12:Envelope/soap12:Body/wsmc:MakeConnection and (wsil:httpHeaders/wsil:contentTypeHeader/wsil:parameter/@key = 'action' )] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | action parameter of the HTTP Content-Type header does not contain the value "http://docs.oasis-open.org/ws-rx/wsmc/200702/MakeConnection". |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2050 |
|---|---|
| General Notes: | . |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope in which any of the following appear: a. wsmc:UnsupportedSelection b. wsmc:MissingSelection |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] has a wsa:RelatesTo that points to an MC with wsa:MessageId, AND the wsa:To matches the wsa:FaultTo (or wsa:ReplyTo if no faultTo). |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP2050 |
|---|---|
| Description: | |
| Target: | [*:Body/*:Fault//*:Value[ (: fn:namespace-uri-for-prefix(fn:substring-before(string(node()),':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsmc/200702' and :) (fn:contains(string(node()), 'MissingSelection') or fn:contains(string(node()), 'UnsupportedSelection'))] or *:Body/*:Fault//*:faultcode[ (: fn:namespace-uri-for-prefix(fn:substring-before(string(node()),':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsmc/200702' and :) (fn:contains(string(node()), 'MissingSelection') or fn:contains(string(node()), 'UnsupportedSelection'))] ] |
| Predicate: | ( not($target/*:Header/wsa:To) or ($target/*:Header/wsa:To = $mc/*:Header/wsa:FaultTo/wsa:Address or (not($mc/*:Header/wsa:FaultTo) and ($target/*:Header/wsa:To = $mc/*:Header/wsa:ReplyTo/wsa:Address or (not($mc/*:Header/wsa:ReplyTo) and fn:contains($target/*:Header/wsa:To, 'http://www.w3.org/2005/08/addressing/anonymous') ) )))) :) ) or (not($mc/*:Header/wsa:MessageID) and $mc/../../@conversation = $target/../../@conversation and (not($target/*:Header/wsa:To) or fn:contains($target/*:Header/wsa:To, 'http://www.w3.org/2005/08/addressing/anonymous')) ) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2100 |
|---|---|
| General Notes: | There's an option in the MC spec that allows for the retrieval of messages based on things other than the target URI – however, RSP limits this by requiring that a search MUST, at least, be based on the target URI (ie. the wsa:To URI). |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with s:Body/MC |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there exists MC/wsmc:Address child element |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: | provide context and cause MC sending such as do a req/resp and the response is lost. Flag=much more difficult study required to force use of MC. Run some request/response tests and set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template |
| Test Assertion: | RSP2100 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2102 |
|---|---|
| General Notes: | Counterpart of RSP2100 (in case of violation) |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with s:Body/MC and no wsmc:Address |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there exists a Fault generated in response |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP2102 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | *:Body/*:Fault//*:faultcode[ (: fn:namespace-uri-for-prefix(fn:substring-before(string(node()),':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsmc/200702' and :) fn:contains(string(node()), 'MissingSelection')] ] satisfies ($target/*:Header/wsa:MessageID = $mcfault/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] or (not($target/*:Header/wsa:MessageID) and $mcfault/../../@conversation = $target/../../@conversation)) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2101 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with s:Body/MC |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there is no MC/wsrm:Identifier |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: | provide context and cause MC sending such as do a req/resp and the response is lost. Flag=much more difficult study required to force use of MC. Run some request/response tests and set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template |
| Test Assertion: | RSP2101 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2103 |
|---|---|
| General Notes: | Counterpart of RSP2101 (in case of violation) |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with s:Body/MC and with wsrm:Identifier |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there exists a Fault generated in response |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP2103 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | *:Body/*:Fault//*:faultcode[ (: fn:namespace-uri-for-prefix(fn:substring-before(string(node()),':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsmc/200702' and :) fn:contains(string(node()), 'UnsupportedSelection')] ] satisfies ($target/*:Header/wsa:MessageID = $mcfault/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] or (not($target/*:Header/wsa:MessageID) and $mcfault/../../@conversation = $target/../../@conversation)) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2110 |
|---|---|
| General Notes: | While the MakeConnection specification allows for any URI to be used in the mc:Address element, for the purposes of increasing interoperability the RSP narrows its usage down to just the cases of the MCAnonymous URI |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | Any message that contains a MakeConnection element in the Body |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] contains an mc:MakeConnection/mc:Address child element whose value is an instance of the MC Anonymous URI template (ie. starts with 'http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id=' ). |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Run some request/response tests and set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template. |
| Test Assertion: | RSP2110 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2113 |
|---|---|
| General Notes: | To ensure all of the RM features can be used, even when a non-addressable endpoint is used, the RSP requires implementations to use an instance of the MC Anonymous URI in the CS/Offer/Endpoint EPR. |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | A CreateSequence message that contains an Offer element. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] does not have a CreateSequence/Offer/wsa:Address element with a value of wsa:Anonymous or wsa:None. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Run some reliable request/response tests where the client is non-addressable and make sure the CreateSequence contains an Offer. |
| Test Assertion: | RSP2113 |
|---|---|
| Description: | |
| Target: | [*:Body/wsrm:CreateSequence/wsrm:Offer and fn:contains(xsd:string(*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Endpoint/*:Address), 'none')) |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0020 |
|---|---|
| General Notes: | The most obvious case is of an endpoint automatically closing an offered sequence (for which it acts as an RMS) after the offering sequence was closed by the other endpoint. (RMS of the offering). Difference ni test envts: (a) controlled env: can be sure the other endpoint did NOT decide to close the offered sequence. (b) uncontrolled envt: cannot be sure of this...: warning only. |
| Coverage Assessment: | fair |
| Target Type: | |
| Test Target: | A SOAP Envelope that contains a CloseSequence or TerminateSequence, related to a sequence that was created by the same sender using a CreateSequence containing an Offer. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | There is no CloseSequence or TerminateSequence for the offered sequence , that is generated by the destination endpoint (of the offering sequence), in response to its termination via the [target message]. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=warning |
| Test Control: | Initiate a Secure Sequence (wsrm:CreateSequence element with an Offer). The RMD sends back CSR with an Accept. Then RMS is sending messages over this sequence, and termiantes the sequence. The RMD is NOT instructed to terminate the Offered sequence. |
| Test Assertion: | RSP0020 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0101 |
|---|---|
| General Notes: | NOTE1:The TA should only apply when there is evidence of message resending. NOTE2: "continuation of resending" is hard to evaluate. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE(CS or CSR) |
| Test Target: | For either a CloseSequence message or a CloseSequenceResponse message sent by RMS, and if there is evidence of resending for a message sent before this CloseSequence[Response], over this sequence. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The same message is NOT resent after the CloseSequence[Response] was sent. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | The RM resending parameters are set in a way that a message capture log can reflect the actual resending over time. Sequence must be closed by RMD or RMD, before the resending schedule expires. |
| Test Assertion: | RSP0101 |
|---|---|
| Description: | |
| Target: | [*:Body/wsrm:CloseSequence or *:Body/wsrm:TerminateSequence] [some $seqid in *:Body//wsrm:Identifier satisfies some $env1 in ./preceding::*:Envelope[*:Header/wsrm:Sequence/wsrm:Identifier = $seqid] satisfies |
| Predicate: | some $seqid in ./*:Body//wsrm:Identifier satisfies (some $env1 in ./preceding::*:Envelope[*:Header/wsrm:Sequence/wsrm:Identifier = $seqid ] satisfies *:Header/wsrm:Sequence/wsrm:MessageNumber = $env1/*:Header/wsrm:Sequence/wsrm:MessageNumber ])) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0102 |
|---|---|
| General Notes: | NOTE1: a message should be intercepted, causing a gap in the Ack ranges. Regardless of how long the delay before resending , the message must finally be acknowledged if sequence not closed. |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE(with RM header) |
| Test Target: | For a message that is a resend, in a RM sequence that is not closed or terminated yet. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The message is not faulted by the RMD, AND the next acknowledgement shows it has been acknowledged. |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: | MIM to block messages, to cause significant delay in resending. |
| Test Assertion: | RSP0102 |
|---|---|
| Description: | |
| Target: | [*:Header/wsrm:Sequence = preceding::*:Envelope/*:Header/wsrm:Sequence] [some $tgenv in . satisfies $clseq/*:Body//wsrm:Identifier = $tgenv/*:Header/wsrm:Sequence/wsrm:Identifier ) |
| Predicate: | some $ackrange in $env/*:Header/wsrm:SequenceAcknowledgement/wsrm:AcknowledgementRange satisfies $ackrange/@Upper ge $target/*:Header/wsrm:Sequence/wsrm:MessageNumber) ) and not (/wsil:testLog/wsil:messageLog/wsil:message[ (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[not (@RelationshipType) or ( @RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' ) ] = $target/*:Header/wsa:MessageID)] /wsil:messageContents/*:Envelope/*:Body/*:Fault ) |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0110 |
|---|---|
| General Notes: | : The test assertion can just focus on the CreateSequence. Assume the CS message has wsa:MessageID, do we expect the same wsa:MessageID to be found in the resend, like R0120 requires for regular traffic messages? I don't think so. All we are interested in, is seeing the RMS resending on its own a CS (possibly different, even the seq ID in the "Offer" might have during such resending). When used in a controoled test envt (see "Test Control") it is best to set ReplyTo anon for the CS. But in a more general situation, one should also test for the "non-anon" case which is most likely to NOT be answered as it requires a new connection. |
| Coverage Assessment: | fair |
| Target Type: | |
| Test Target: | A SOAP Envelope that contains a CreateSequence, that has not been replied to (no CSR). NOTE: Both reply cases (anon ReplyTo and non-anon) must be considered. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | There is a CS iniitated by same endpoint as for the [target message], with same characteristics (e.g. w/o Offer, and wsa headers) that follows the non-answered [target message]. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=warning |
| Test Control: | Two test envts are possible: (a) an RMS initiating a sequence with a destination endpoint that is simply not RM-enabled (so no CSR will ever come back), (b) an RMS initiating a sequence with an RM-enabled destination. but an interception tool is capturing and dropping the CSR. NOTE: only (b) can be used for testing all lifecycle messages and not just CS. Also, both reply cases - anon and non-anon - must be considered. |
| Test Assertion: | RSP0110 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | COM0200 |
|---|---|
| General Notes: | untestable without ESP, hard to simulate an rmd autonomous decision to discontinue a sequence hard to impossible. |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | COM0200 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | COM0500 |
|---|---|
| General Notes: | very hard to stimulate if at all (a heck of a lot of work) |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | COM0500 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0501 |
|---|---|
| General Notes: | Section 3.9 of WS-RM says that, when AcksTo is anonymous, the only way to transmit acknowledgments is over the back-channel created by an STM that is within the sequence to which the ack applies. The text in WS-RM applies to all acknowledgements. This requirement highlights piggybacked acknowledgments as a special case of this general rule. Crafting an assertion that checks for violation of this requirement should be fairly straightforward. However, to have any meaningful coverage, we need test scenarios that create an environment capable of stimulating the incorrect behavior. Essentially we need scenarios in which a single client/RMS creates two or more sequences with a single server/RMS using anonymous AcksTos in all the sequences and sends a either a series of one-way message or a series of request-response messages. To keep things simple, this later variation should not include reliability for the response messages |
| Coverage Assessment: | Partial (piggybacking difficult to stimulate). |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope in which: a. One or more SequenceAcknowledgment headers appear. b. The Body is not empty. c. The value of wsa:To is http://www.w3.org/2005/08/addressing/anonymous or in which wsa:To is absent. d. Transmitted in the body of an HTTP Response. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of each /wsrm:SequenceAcknowledgment/wsrm:Identifier element in the [target] matches the value of the /wsrm:Sequence/wsrm:Identifier in the message contained in the corresponding HTTP Request. |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: | Scenario: x.x.x Reliable_One_Way_Requests_Anon_AcksTo_Multiple_Sequences The client creates two sequences to the service in the identical way; the CreateSequence message contains an anonymous AcksTo and there is no Offer. The service supports a one-way message. The client reliably sends a number of messages to the service, alternating the sequence for each message. Scenario: x.x.x Reliable_Requests_Unreliable_Response_Anon_AcksTo_Multiple_Sequences The client creates two sequences to the service in the identical way; the CreateSequence message contains an anonymous AcksTo and there is no Offer. The service is configured to support reliable-request/non-reliable response. The client reliably sends a number of messages to the service, alternating the sequence for each message. |
| Test Assertion: | RSP0501 |
|---|---|
| Description: | |
| Target: | [*:Header/wsrm:SequenceAcknowledgement and (some $tgt in . satisfies some $cs in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Body/wsrm:CreateSequence/wsrm:AcksTo/wsa:Address = 'http://www.w3.org/2005/08/addressing/anonymous'] satisfies (some $csr in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Body/wsrm:CreateSequenceResponse] satisfies ($tgt/*:Header/wsrm:SequenceAcknowledgement/wsrm:Identifier = $csr/*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier and ($csr/../../@conversation = $cs/../../@conversation or $csr/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $cs/*:Header/wsa:MessageID)))) ] |
| co-Target: myRequestMsg | [@type = 'request' and (@conversation = $target/../../@conversation or .//*:Header/wsa:MessageID = $target//wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)]) ] |
| Prerequisite: | |
| Predicate: | ($seqack/wsrm:Identifier = $myRequestMsg//*:Envelope/*:Header/wsrm:Sequence/wsrm:Identifier)) or ($target/*:Body/wsrm:TerminateSequenceResponse/wsrm:Identifier = $myRequestMsg//*:Envelope/*:Body/wsrm:TerminateSequence/wsrm:Identifier) or ($target/*:Body/wsrm:CloseSequenceResponse/wsrm:Identifier = $myRequestMsg//*:Envelope/*:Body/wsrm:CloseSequence/wsrm:Identifier)) and ($target/*:Header/wsa:To = 'http://www.w3.org/2005/08/addressing/anonymous' or not($target/*:Header/wsa:To) ) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0510 |
|---|---|
| General Notes: | As the explanatory text describes, this requirement is about enforcing the following invariant: for Sequences in which the AcksTo EPR contains ReferenceParameters, any message containing SequenceAcknowledgement header(s) for such Sequences will also contain the AcksTo/wsa:ReferenceParameters in its SOAP headers. It is possible to create a test assertion for this requirement by correlating SequenceAcknowlement headers against the CreateSequence message for the Sequence to which they apply and checking for the presence of reflected reference parameter elements. As with the test for R0501, the problem lies in the test coverage. Without specific knowledge of an implementation, it is difficult to guess what might trigger it to piggyback acknowledgements. The best that can be done is to run test scenarios that create Sequences in which the AcksTo EPR contains reference parameters and see if there are any cases in which the SequenceAcknowledgment is not accompanied by the reflected reference parameter headers. |
| Coverage Assessment: | Partial (piggybacking difficult to stimulate). |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope in which: a. One or more SequenceAcknowledgment headers appear. b. The Body is a not empty. c. The Sequence identified by /wsrm:SequenceAcknowledgment/wsrm:Identifier was created by a CreateSequence message in which /wsrm:CreateSequence/wsrm:AcksTo/wsa:ReferenceParameters was not empty. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The value of each child element of /wsrm:CreateSequence/wsrm:AcksTo/wsa:ReferenceParameters must appear as a SOAP Header in the [target] and must be annotated with the wsa:IsReferenceParameter attribute. No other SOAP Headers besides these should be so annotated. |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: | (additional scenarios) Scenario: x.x.x Reliable_Request_Response_AcksTo_RefParm The client creates a sequence to the service with a CreateSequence message that contains a non-anonymous AcksTo with ReferenceParameters. The CreateSequence may or may not contain an Offer. The service supports reliable requests and either reliable or non-reliable responses. The client reliably sends a number of messages to the service. The /wsa:ReplyTo/wsa:Address for all these request should be identical to the /wsrm:CreateSequence/wsrm:AcksTo/wsa:Address but the /wsa:ReplyTo/wsa:ReferenceParameters should alternate between a set that is identical to /wsrm:CreateSequence/wsrm:AcksTo/wsa:ReferenceParameters and a set that is different. |
| Test Assertion: | RSP0510 |
|---|---|
| Description: | |
| Target: | [ *:Header[wsrm:SequenceAcknowledgement and not(*:Header/wsse:Security//xenc:ReferenceList)] and *:Body[node() and not(*:Fault) and not(wsrm:*)]] [ some $tgt in . satisfies some $csr in /wsil:testLog/wsil:messageLog/wsil:message//*:Envelope[*:Body/wsrm:CreateSequenceResponse][$tgt/*:Header/wsrm:SequenceAcknowledgement/wsrm:Identifier = *:Body/wsrm:CreateSequenceResponse/wsrm:Identifier] satisfies some $cs in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Body/wsrm:CreateSequence] satisfies ($csr/../../@conversation = $cs/../../@conversation or $csr/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $cs/*:Header/wsa:MessageID)] |
| co-Target: mycreateseq | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0620a |
|---|---|
| General Notes: | For SOAP11 |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope in which any of the following appear: a. wsrm:SequenceTerminated b. wsrm:UnknownSequence c. wsrm:InvalidAcknowledgment d. wsrm:MessageNumberRollover e. wsrm:CreateSequenceRefused f. wsrm:SequenceClosed g. wsrm:WSRMRequired |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] does not contain a wsrm:Sequence header. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | TBD – a scenario that causes either a wsrm:SequenceTerminated or wsrm:UnknownSequence fault. |
| Test Assertion: | RSP0620a |
|---|---|
| Description: | |
| Target: | [*:Body/*:Fault] [some $fc in *:Header/*:SequenceFault/*:FaultCode satisfies (fn:namespace-uri-for-prefix(fn:substring-before($fc,':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsrm/200702') or ( fn:substring-after($fc,':' ) eq 'SequenceTerminated' or fn:substring-after($fc,':' ) eq 'UnknownSequence' or fn:substring-after($fc,':' ) eq 'InvalidAcknowledgment' or fn:substring-after($fc,':' ) eq 'CreateSequenceRefused' or fn:substring-after($fc,':' ) eq 'MessageNumberRollover' or fn:substring-after($fc,':' ) eq 'SequenceClosed' or fn:substring-after($fc,':' ) eq 'WSRMRequired' )] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0620b |
|---|---|
| General Notes: | For SOAP12 |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope in which any of the following appear: a. wsrm:SequenceTerminated b. wsrm:UnknownSequence c. wsrm:InvalidAcknowledgment d. wsrm:MessageNumberRollover e. wsrm:CreateSequenceRefused f. wsrm:SequenceClosed g. wsrm:WSRMRequired |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] does not contain a wsrm:Sequence header. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | TBD – a scenario that causes either a wsrm:SequenceTerminated or wsrm:UnknownSequence fault. |
| Test Assertion: | RSP0620b |
|---|---|
| Description: | |
| Target: | [*:Body/*:Fault] [some $fc in *:Body/*:Fault//*:Value satisfies (fn:namespace-uri-for-prefix(fn:substring-before($fc,':' ) , . ) = 'http://docs.oasis-open.org/ws-rx/wsrm/200702') or ( fn:substring-after($fc,':' ) eq 'SequenceTerminated' or fn:substring-after($fc,':' ) eq 'UnknownSequence' or fn:substring-after($fc,':' ) eq 'InvalidAcknowledgment' or fn:substring-after($fc,':' ) eq 'MessageNumberRollover' or fn:substring-after($fc,':' ) eq 'CreateSequenceRefused' or fn:substring-after($fc,':' ) eq 'SequenceClosed' or fn:substring-after($fc,':' ) eq 'WSRMRequired' )] |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | COM0700 |
|---|---|
| General Notes: | not testable since generated faults may not be visible or if testable will never fail |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | COM0700 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0800 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0800 |
|---|---|
| Description: | |
| Target: | [*:Body/wsrm:CreateSequence][ some $cs in . satisfies some $mycsr in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope [*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier = /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope/*:Header/wsrm:Sequence/wsrm:Identifier] satisfies ($mycsr/../../@conversation = $cs/../../@conversation) or ($mycsr/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $cs/*:Header/wsa:MessageID)] |
| Predicate: | [*:Body/wsrm:CreateSequenceResponse] [(./../../@conversation = $target/../../@conversation) or (*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID)] satisfies some $env in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Header/wsrm:Sequence/wsrm:Identifier = $mycsr/*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier] satisfies ($env/*:Header/wsa:To = $target/*:Header/wsa:To) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0900 |
|---|---|
| General Notes: | When passing around EPRs (that do not have embedded WSDL) it is not clear which version of SOAP should be used when talking to that EPR. This requirement tries to answer this question at least with respect to RM Acks / AcksTo EPR by requiring the RMD to use the same SOAP version that was used in the originating CS message. This means that the RMD needs to save this information, where before this was not required |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope with a SeqAck Header |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] has the same SeqID value and SOAP Envelope namespace as the previous message that contains a CreateSequence or CreateSequenceResponse. |
| Prescription: | mandatory |
| Reporting: | true=warning, false=passed |
| Test Control: | Run a reliable request/response application message exchange. Create a sequence using a CreateSequence that includes an Offer element. This will ensure that the messages carrying the Acks in both directions are using the correct SOAP namespace. |
| Test Assertion: | RSP0900 |
|---|---|
| Description: | |
| Target: | [(*:Header/wsrm:SequenceAcknowledgement/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier) or (*:Body/wsrm:CloseSequenceResponse/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier) or (*:Body/wsrm:TerminateSequenceResponse/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier) or (*:Body/wsrm:CreateSequenceResponse)] |
| Prerequisite: | RSP8001 |
| Predicate: | [*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier = $target/*:Header/wsrm:SequenceAcknowledgement/wsrm:Identifier or (*:Body/wsrm:CreateSequenceResponse/wsrm:Identifier = $target/*:Body/wsrm:*/wsrm:Identifier)] satisfies some $cs in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope[*:Body/wsrm:CreateSequence] satisfies ($csr/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $cs/*:Header/wsa:MessageID)) and fn:namespace-uri($target) = fn:namespace-uri($cs) |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0540 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good(should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | An ENVELOPE containing AckRequested or SequenceAcknowledgement |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | For any ENVELOPE containing AckRequested or SequenceAcknowledgement, and that is piggybacked (Body not empty), then such headers not have mustUnderstand attribute set to true ('1'). |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: |
| Test Assertion: | RSP0540 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP0901 |
|---|---|
| General Notes: | The possible lifecycle messages covered by this requirement are: CloseSequence and TerminateSequence. Similar to R0900, its not clear what version of SOAP should be used when sending messages to the CS/Offer/Endpoint EPR. This requirement would require an RMD to save the SOAP version of the CS and use that same version of any Close or Terminate Sequence messages sent to the CS/Offer/Endpoint EPR |
| Coverage Assessment: | Good(should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | A CloseSequence or TerminateSequence message |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | For any message that contains a CloseSequence or TerminateSequence element in the Body, extract the SeqID value and find (in a previous message) a CreateSequence, or CreateSequenceResponse, that references this SeqID. The namespace of the SOAP Envelope elements of these messages MUST be the same |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Run a reliable request/response application message exchange. Create a sequence using a CreateSequence that includes an Offer element. To ensure the CloseSequence message is tested we could make sure there's a gap in the request sequence then have the RMS send a Close. This should cause the service to close the response sequence before it terminates it. Question: is there a RSP requirement that covers the non-Offered case? Seems like there should be but I can't find it |
| Test Assertion: | RSP0901 |
|---|---|
| Description: | |
| Target: | [(*:Header/wsrm:AckRequested/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Identifier) or (*:Body/wsrm:CloseSequence/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Identifier) or (*:Body/wsrm:TerminateSequence/wsrm:Identifier = preceding::*:Envelope/*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Identifier) ] |
| Prerequisite: | RSP8001 |
| Predicate: | [*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Identifier = $target/*:Header/wsrm:AckRequested/wsrm:Identifier or (*:Body/wsrm:CreateSequence/wsrm:Offer/wsrm:Identifier = $target/*:Body/wsrm:*/wsrm:Identifier)] satisfies fn:namespace-uri($target) = fn:namespace-uri($cs) |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1000 |
|---|---|
| General Notes: | NOTE1: We are not sure how to stimulate this fault. we might be able to send a particular token that we do not expect any service to (willingly) support. or we could send all of the type of well known tokens and report those that are not supported by a particular implementation report this specific fault. can test only those tokens we make up or know about (cannot test all potential custom tokens) |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE (Fault) |
| Test Target: | fault returned instead of response to unknown RST, (correlation done with wsa) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | Exists a Fault message that correlates, with faultcode=stated in requirement |
| Prescription: | mandatory |
| Reporting: | true=passed, false=warning |
| Test Control: | generate (or MIM intercept and corrupt) RST that can't be supported. |
| Test Assertion: | RSP1000 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1100 |
|---|---|
| General Notes: | NOTE1: the predicate is weaker than the profile req, hence true=undetermined, but false= a sure failure. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE (with wst:RST) |
| Test Target: | For an Envelope with RST and action URI=.... |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | It has Security header that references SOAP body. |
| Prescription: | mandatory |
| Reporting: | true=undetermined, false=fail |
| Test Control: | Text env: must implement RMS->scenario to generate the TA context |
| Test Assertion: | RSP1100 |
|---|---|
| Description: | |
| Target: | [*:Body//wst:RequestSecurityToken and *:Header/wsa:Action eq 'http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Amend'] |
| Predicate: | ($dsig//ds:Reference[fn:substring-after(@URI, '#') eq $target/@wsu:Id]) or ( (every $cruxp in $target/*:Header/wsrm:* | $target/*:Header/wsa:* satisfies some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id)) (every $cruxp in $target/*:Body/* satisfies some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id )) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | COM1101 |
|---|---|
| General Notes: | untestable due to key comparison issue. Same for R1111, R1121. |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | COM1101 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1110 |
|---|---|
| General Notes: | NOTE1: the predicate is weaker than the profile req, hence true=undetermined, but false= a sure failure. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with RST and action URI=.... |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | It has Security header that references SOAP body. |
| Prescription: | mandatory |
| Reporting: | true=undetermined, false=fail |
| Test Control: | Text env: must implement RMS->scenario to generate the TA context |
| Test Assertion: | RSP1110 |
|---|---|
| Description: | |
| Target: | [*:Body//wst:RequestSecurityToken and *:Header/wsa:Action eq 'http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Renew'] |
| Predicate: | ($dsig//ds:Reference[fn:substring-after(@URI, '#') eq $target/@wsu:Id]) or ( some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id)) (every $cruxp in $target/*:Body/* satisfies some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id )) |
| Reporting: | true=warning, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1120 |
|---|---|
| General Notes: | NOTE1: the predicate is weaker than the profile req, hence true=undetermined, but false= a sure failure. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with RST and action URI=.... |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | It has Security header that references SOAP body. |
| Prescription: | mandatory |
| Reporting: | true=undetermined, false=fail |
| Test Control: | Text env: must implement RMS->scenario to generate the TA context |
| Test Assertion: | RSP1120 |
|---|---|
| Description: | |
| Target: | [*:Body//wst:RequestSecurityToken and *:Header/wsa:Action eq 'http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Cancel'] |
| Predicate: | ($dsig//ds:Reference[fn:substring-after(@URI, '#') eq $target/@wsu:Id]) or ( (every $cruxp in $target/*:Header/wsrm:* | $target/*:Header/wsa:* satisfies some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id)) (every $cruxp in $target/*:Body/* satisfies some $ref in $dsig//ds:Reference satisfies fn:substring-after($ref/@URI, '#') = $cruxp/@wsu:Id )) |
| Reporting: | true=warning, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1121 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: |
| Test Assertion: | RSP1121 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1200 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with RST/SCT/renew action URI |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | It correlates with RSTR/SCT that correlates with original RST and renew that has auth mechanism |
| Prescription: | mandatory |
| Reporting: | true=warning, false=warning |
| Test Control: |
| Test Assertion: | RSP1200 |
|---|---|
| Description: | |
| Target: | |
| co-Target: myOriginalRSTR | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1001 |
|---|---|
| General Notes: | This is a scenario-dependent TA: it only triggers on "non-recognized" content of a certain kind: element with a namespace = http://dummy.example.org/unknown/nmspace |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with an SCT that has been obtained from a previous RSTR message, where the SCT did first appear with an unrecognizable content |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The used SCT still has the same unrecognizable content. |
| Prescription: | mandatory |
| Reporting: | true=pass, false=failed |
| Test Control: | scenario to provide context. |
| Test Assertion: | RSP1001 |
|---|---|
| Description: | |
| Target: | [ some $sct in *:Header//wssc:SecurityContextToken satisfies some $sct0 in /wsil:testLog/wsil:messageLog/wsil:message/wsil:messageContents/*:Envelope//wst:RequestSecurityTokenResponse//wssc:SecurityContextToken satisfies $sct0/wssc:Identifier = $sct/wssc:Identifier and (some $elt in $sct0//* satisfies string(fn:namespace-uri($elt)) = 'http://dummy.example.org/unknown/nmspace') ] |
| Predicate: | string(fn:namespace-uri($elt)) = 'http://dummy.example.org/unknown/nmspace' |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1300 |
|---|---|
| General Notes: | NOTE1:Type=Feature Usage. NOTE2: investigate ways at improving the context. NOTE3: coverage is good, but possiblemany false negatives |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with wssc:Security or RST or RSTR and with SCT refs |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | In the envelope, there exists wssc:STR/ref [@URI does not start with "#"] |
| Prescription: | mandatory |
| Reporting: | true=pass, false=warning |
| Test Control: | scenario to provide context. |
| Test Assertion: | RSP1300 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1310 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope with wsc:DKT |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | there exists DKT/STR and there exists a message with (SCT/identifier=STR/Refrence@URI) |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP1310 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=warning, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3010 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | For an Envelope that contains a wsrm:CreateSequence element that has security token ref |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | Envelope includes the UsesSequenceSTR header |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: | scenario provide the expected "context" (manipulate content of CreateSequence) |
| Test Assertion: | RSP3010 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3100a |
|---|---|
| General Notes: | The signature elt contains a key ref that points to CreateSequence (the CS defining a Secured RM Sequence), and either (a) the sig signs directly the Body, or (b) signs another sig element with same key ref, that itself references the Body. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE |
| Test Target: | In an Envelope that belong to a secured RM seq. (has a related qualifying CS that contains UsesSequenceSTR) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | (negative case) there is a sig element that signs the seq Header that does not also reference the Body OR there is no element that signs the body |
| Prescription: | mandatory |
| Reporting: | true=fail, false=undetermined |
| Test Control: |
| Test Assertion: | RSP3100a |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3100b |
|---|---|
| General Notes: | The signature elt contains a key ref that points to CreateSequence (the CS defining a Secured RM Sequence), and either (a) the sig signs directly the Body, or (b) signs another sig element with same key ref, that itself references the Body. |
| Coverage Assessment: | Partial |
| Target Type: | ENVELOPE |
| Test Target: | In an Envelope that belong to a secured RM seq. (has a related qualifying CS that contains UsesSequenceSTR) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | (negative case) there is a sig element that signs the seq Header that does not also reference the Body OR there is no element that signs the body |
| Prescription: | mandatory |
| Reporting: | true=fail, false=undetermined |
| Test Control: |
| Test Assertion: | RSP3100b |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3101a |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: |
| Test Assertion: | RSP3101a |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3100a |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3101b |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: |
| Test Assertion: | RSP3101b |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3100b |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2112 |
|---|---|
| General Notes: | This requirement focuses on ensuring that when RM is being used by an anonymous endpoint, that the MC Anonymous URI is used so that the full features of RM can still continue to be used. So: IF MC anon used in request, and same used i response/wsa:To then OK else Fail. IF MC anon not used in request, but regular anon, THEN fail. |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | Any Message sent on an HTTP response flow that contains a wsrm:Sequence Header. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] has a wsa:To Header whose value is an instance of the MC Anonymous URI (ie. starts with "http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id="). |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Run some request/response tests and set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template. |
| Test Assertion: | RSP2112 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP2111 |
|---|---|
| General Notes: | This is a test to make sure that messages targeted to the MakeConnection Anonymous URI flow over an HTTP response flow (as opposed to an HTTP request flow). |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | A message with a wsa:To value set to an instance of the MC Anonymous URI template (ie. starts with "http://docs.oasis-open.org/ws-rx/wsmc/200702/anonymous?id=" ). |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The [target] is an HTTP response message. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Run some request/response tests and set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template. |
| Test Assertion: | RSP2111 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3102 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good |
| Target Type: | ENVELOPE |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | true=pass, false=fail |
| Test Control: |
| Test Assertion: | RSP3102 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3110a |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | RSP3110a |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3110b |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | |
| Test Control: |
| Test Assertion: | RSP3110b |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3114a |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3114a |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3110a |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3114b |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | |
| Test Target: | |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3114b |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3110b |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3117a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap12 Fault. a SOAP12 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | like R3110 |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3117a |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3117b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap12 Fault. a SOAP12 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | like R3110 |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3117b |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3120a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | like R3100 |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3120a |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3120b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | like R3100 |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3120b |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3120c |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | like R3100 |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3120c |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3121a |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. a SOAP11 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3121a |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3120a |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3121b |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. a SOAP11 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP3121b |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP3120b |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1400 |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with a signed body and some wsa headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP1400 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1401 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. a SOAP11 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP1401 |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP1400 |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1402 |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with a signed body and some wsa headers. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP1402 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP1403 |
|---|---|
| General Notes: | |
| Coverage Assessment: | partial (does not cover UnknownSequence Fault) |
| Target Type: | ENVELOPE |
| Test Target: | Envelope with Soap11 Fault. a SOAP11 fault that has in its detail element wsrm identifier that refers to a known Secured Seq |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: |
| Test Assertion: | RSP1403 |
|---|---|
| Description: | |
| Target: | |
| Prerequisite: | RSP1402 |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3201 |
|---|---|
| General Notes: | |
| Coverage Assessment: | |
| Target Type: | ENVELOPE |
| Test Target: | Env contains MessagePending header AND whose Body is being signed (relates to Secured RM Seq) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | (a) is signed, (b) signature covers both the header block and the Body. The [target]'s security Header that indicates the Body is signed also includes a reference to the wsu:Id of the MessagePending Header |
| Prescription: | mandatory |
| Reporting: | (default) |
| Test Control: | Run some secure request/response tests where there are several request messages being processed at the same time (ie. they are not serialized). Also, set the wsa:ReplyTo of the request messages (from a non-addressable endpoint) to an instance of the MC Anonymous URI Template. |
| Test Assertion: | RSP3201 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3300 |
|---|---|
| General Notes: | |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope that belongs to a Secure Sequence, i.e. with a wsrm:Sequence/wsrm:Identifier element that match the wsrm:CreateSequenceResponse/wsrm:Identifier that is response of a wsrm:CreateSequence element extended with a wsse:SecurityTokenReference element. |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | The SOAP Envelope contains a wsse:Security header that has a wsu:Timestamp child element. |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | No WS-SecurityPolicy assertions will be deployed or published. Initiate a Secure Sequence (wsrm:CreateSequence element has been extended with a wsse:SecurityTokenReference element). Then RMS is sending messages over this sequence. |
| Test Assertion: | RSP3300 |
|---|---|
| Description: | |
| Target: | |
| co-Target: mycreateseq | |
| Prerequisite: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Analysis: | RSP3301 |
|---|---|
| General Notes: | This is a more general situation than R3300: a WS-SecurityPolicy assertions may or may not be deployed, that controls the presence of wsu:Timestamp. Although the Rxxxx is considering a pair of Envelopes, the test target (and predicate) focus on a single one at a time. |
| Coverage Assessment: | Good (should be able to cover all cases) |
| Target Type: | ENVELOPE |
| Test Target: | A SOAP Envelope that belongs to a Secure Sequence, (see the filter condition in R3300 for this) |
| Test co-Target(s): | |
| Test Prerequisite: | |
| Predicate: | if the SOAP Envelope contains a wsse:Security/wsu:Timestamp child element, then any previous RM retry SOAP Envelope (same wsrm:Sequence/wsrm:Identifier and same wsrm:Sequence/wsrm:MessageNumber) has a different wsse:Security/wsu:Timestamp, else any previous RM retry SOAP Envelope does NOT have wsu:Timestamp under wsse:Security |
| Prescription: | mandatory |
| Reporting: | true=passed, false=failed |
| Test Control: | Initiate a Secure Sequence (wsrm:CreateSequence element has been extended with a wsse:SecurityTokenReference element). Then RMS is sending messages over this sequence. Manage to cause message resending (block Acks, or set the retry period shorter than the Ack period.) |
| Test Assertion: | RSP3301 |
|---|---|
| Description: | |
| Target: | |
| co-Target: mycreateseq | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1004 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | preferred |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1006a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Prerequisite: | |
| Predicate: | |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1006b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Prerequisite: | |
| Predicate: | then ( fn:ends-with($myresponse/soap11:Body/soap11:Fault/faultcode, 'ActionNotSupported') ) else ( fn:ends-with($myresponse/soap12:Body/soap12:Fault/soap12:Code/soap12:Value, 'Sender') and fn:ends-with($target/soap12:Body/soap12:Fault/soap12:Code/soap12:Subcode/soap12:Value, 'ActionNotSupported') ) ) |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1007a |
|---|---|
| Description: | |
| Target: | |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Predicate: | then ( fn:ends-with($myresponse/soap11:Body/soap11:Fault/faultcode, 'ActionNotSupported') ) else ( fn:ends-with($myresponse/soap12:Body/soap12:Fault/soap12:Code/soap12:Value, 'Sender') and fn:ends-with($myresponse/soap12:Body/soap12:Fault/soap12:Code/soap12:Subcode/soap12:Value, 'ActionNotSupported') ) ) ) |
| Reporting: | true=passed, false=failed |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1007b |
|---|---|
| Description: | |
| Target: | |
| co-Target: myresponse | (@type = 'response' and @conversation = $target/../../@conversation) or (.//*:Envelope/*:Header/wsa:RelatesTo[@RelationshipType = 'http://www.w3.org/2005/08/addressing/reply' or not (@RelationshipType)] = $target/*:Header/wsa:MessageID) ] /wsil:messageContents/*:Envelope |
| Prerequisite: | RSP1007a |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | mandatory |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion: | RSP1008 |
|---|---|
| Description: | |
| Target: | |
| Predicate: | |
| Reporting: | true=passed, false=warning |
| Prescription: | preferred |
| Error Message: | |
| Diagnostic Data: |
| Test Assertion Part | What it means: |
|---|---|
| Test Assertion ID: | [markup: testAssertion/@id] (required) A unique ID for the current test assertion. |
| Description: | [markup: testAssertion/description ] (optional) A plain text description of the current test assertion. At minimum expressing the TA predicate. |
| Comments: | [markup: testAssertion/comments ] (optional) A plain text comment about the TA script and how well it covers the profile requirement. Explanation material for users, and developers (what could be improved, etc.). |
| Target: | [markup: testAssertion/target ] (required) The artifacts to be tested, defined by an XPath expression that returns a list of XML nodes from the log file in input. For every artifact (node) selected by the Target expression, there will be a report entry for this TA in the test report, with a result of either:
See the "reporting" item for the meaning of these results. |
| Cotarget: | [markup: testAssertion/cotarget ] (optional) Artifact that is related to the target, and that needs be accessed for the testing. Identified by an XPath expression that may refer to the related target node using the variable '$target'. For example, the target can be a SOAP message and the cotarget the WSDL file that describes this SOAP message. A cotarget must have a @name attribute that identifies it. The value of this attribute can be used as a variable (when prepending '$' to it) by subsequently defined cotargets, prerequisite and predicate. |
| Prerequisite: | [markup: testAssertion/@preReq ] (optional) [markup: testAssertion/prerequisite ] (optional) The pre-condition for evaluating this Test Assertion on this target. If the prerequisite evaluates to "false" then the target does not qualify for this Test Assertion (the test report is "notRelevant") The first part (preReq attribute) is an enumeration of Test Assertion IDs. Each one of the prerequisite TAs must either use the same target (e.g. SOAP Envelope, or WSDL binding, etc.) as this TA, or a target that is of a more general type than the main TA target. The target must "pass" each one of these prerequisite TAs in order to qualify for this TA. (e.g. the target of TA t1 can be a WSDL binding while the target of a TA t2 prerequisite of t1, can be the entire WSDL file). The second part ("prerequisite" element) is an XPath (boolean) expression of the same nature as the predicate. If present, it must evaluate to "true" for the target to qualify. If it fails, the result for the current TA in the report will be "notRelevant". Otherwise, the target can be further evaluated by the predicate of the main TA. The expression may refer to the target explicitly using the variable name "$target", or to any cotarget using its name as variable name ($[name]). |
| Predicate: | [markup: testAssertion/predicate] required element] A logical expression that evaluates whether this target is fulfilling the profile requirement addressed by this test Assertion. By default: - A result of true means the requirement is fulfilled (reported as a "passed" in the test report).- A result of false means the requirement is violated (reported as a "failed" in the test report). However, in some cases and for testability reasons, the predicate may be designed as a partial indicator e.g. only indicates some cases of fulfillment, or some cases of violation. As a result, when "true" indicates fulfillment it may be that "false" is unconclusive, or conversely "false" will indicate violation, but "true" is unconclusive. In such cases, the "Reporting" element specifies the meaning of the predicate result w/r to the profile requirement. The predicate expression implicitly refers to the target (whic is its "XPath context") although it may explicitly refer to it using the variable name "$target". It may refer to any cotarget using its name as variable name ($[name]). |
| Prescription: | [markup: testAssertion/prescription/@level ] (required) Conveys the level of prescription associated with the profile requirement. At least three values may be used:
|
| Reporting: | [markup: testAssertion/reporting ] (optional) For each possible outcome of the predicate (true or false), specifies how it must be interpreted w/r to the profile feature. Two attributes are used that both must be present, when this element is present:
NOTES: the predicate of the TA may be worded in a negative way so that @false='passed' although that is not recommended. The result of a test should not be related to the prescription level, e.g. a "preferred" or "permitted" level should not imply that @false='warning'. Other test results that are automatically generated and not controlled by the "reporting" element are:
|