TIDRestFunctions

Last Updated:

Actions for REST request such as GET, PUT, POST, DELETE etc.

This keyword library provides REST Actions that can be used by all three DDE Drivers--CycleDriver, SuiteDriver, and StepDriver. That means they can be used in any keyword driven test tables regardless of the test tables level--Cycle, Suite, or Step.

Each different action has different parameters as described in its documentation. For reference, the first fields of ALL REST Action test records are defined below:

First Fields Description

Field #1
The "T" = Component Action record type specifier.
Field #2
The "SAFSREST" = Flag for REST action.
It can be
  • a literal string "SAFSREST"
  • a map item of any name given by user, but the value MUST be "SAFSREST", such as
    --------- Map file example -------
    [RestServiceTest]
    RestServiceTest=SAFSREST
    -----------------------------------
Field #3
The "SessionIDItem" = The map item storing the Session ID.
How to define SessionIDItem
The variable "SessionIDItem" can be defined in the map file under section [ApplicationConstant] or section specified by Field #2, examples as below:
--------- Map file example -------

#T, SAFSREST, SessionIDItem, RestAction
#For above test record, SessionIDItem can be defined under section "SAFSREST"
[SAFSREST]
SessionIDItem=UserAssignedSessionID
#Or SessionIDItem can be defined under section "ApplicationConstant"
[ApplicationConstant]
SessionIDItem=UserAssignedSessionID

#T, RestServiceTest, SessionIDItem, RestAction
#For above test record, SessionIDItem is defined under section "RestServiceTest"
[RestServiceTest]
RestServiceTest=SAFSREST
SessionIDItem=UserAssignedSessionID
#Or SessionIDItem can be defined under section "ApplicationConstant"
[ApplicationConstant]
SessionIDItem=UserAssignedSessionID

-----------------------------------

Notes of SessionIDItem
This ID is assigned by user, who needs to guarantee it is unique.
If the SessionIDItem is provided, the keyword RestStartServiceSession SHOULD be executed before executing each other action keyword, which will be handled within a session, within which:
1. The base URL is stored, and it will be prepended to a relative URI to form a full REST service URL.
2. The authentication information is also stored for later rest action execution.

Otherwise (no SessionIDItem is provided), it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information. The parameter relativeURI should be provided with a full-path URL

Field #4
The REST Action keyword.

Authentication/Authorization settings

Some REST service needs Authentication/Authorization before requesting.
It can be globally set via .ini configuration file or VM parameter as below:
  • .ini configuration file
    #The auth-config file should be assigned to key AUTH under section SAFS_REST
    [SAFS_REST]
    AUTH=config\auth2.xml

  • VM parameter
    #The auth-config file should be assigned to parameter safs.rest.auth
    java -Dsafs.rest.auth=config\auth2.xml aTest
It can also be set via keyword parameter as below:
T, SAFSREST, sessionIDItem, RestGetXML, relativeURI, responseIDVar [, body] [, headers] , config\auth2.xml
Auth setting via keyword parameter will only take effect during this keyword execution, and it will override the global auth setting.

Examples:

T, SAFSREST, sessionIDItem, RestStartServiceSession, baseURL [, authentication]
T, SAFSREST, sessionIDItem, RestGetXML, relativeURI, responseIDVar [, body] [, headers] [, authentication]
T, SAFSREST, sessionIDItem, RestEndServiceSession

Note:
REST Action parameters must be placed in the test record in the field position specified in the documentation. Some parameters are optional. However, the field associated with that parameter must be honored. If you wish to skip an optional parameter you must still provide an empty field for that parameter.



[How To Read This Reference]
RestDeleteBinary
Delete binary content. Not implemented yet.
RestDeleteCSS
Delete css content. Not implemented yet.
RestDeleteCustom
TID
Perform the "DELETE" method on a REST service with headers defined by user.
RestDeleteHTML
RestDeleteImage
Delete image content. Not implemented yet.
RestDeleteJSON
Delete json content. Not implemented yet.
RestDeleteScript
Delete javascript content. Not implemented yet.
RestDeleteText
Delete text content. Not implemented yet.
RestDeleteXML
Delete xml content. Not implemented yet.
RestEndServiceSession
TID
Stop a session for a REST service.
RestGetBinary
TID
Perform the "GET" method on a REST service, and verify the returned content is binary before returning it.
RestGetCSS
TID
Perform the "GET" method on a REST service, and verify the returned content is css before returning it.
RestGetCustom
TID
Perform the "GET" method on a REST service with headers defined by user, and return the content.
RestGetHTML
TID
Perform the "GET" method on a REST service, and verify the returned content is html before returning it.
RestGetImage
TID
Perform the "GET" method on a REST service, and verify the returned content is image before returning it.
RestGetJSON
TID
Perform the "GET" method on a REST service, and verify the returned content is json before returning it.
RestGetScript
TID
Perform the "GET" method on a REST service, and verify the returned content is javascript before returning it.
RestGetText
TID
Perform the "GET" method on a REST service, and verify the returned content is text before returning it.
RestGetXML
TID
Perform the "GET" method on a REST service, and verify the returned content is xml before returning it.
RestHeadBinary
TID
Perform the "HEAD" method on a REST service, and verify the returned content is binary before returning the header part.
RestHeadCSS
TID
Perform the "HEAD" method on a REST service, and verify the returned content is css before returning the header part.
RestHeadCustom
TID
Perform the "HEAD" method (with headers defined by user) on a REST service, and get back the header part.
RestHeadHTML
TID
Perform the "HEAD" method on a REST service, and verify the returned content is html before returning the header part.
RestHeadImage
TID
Perform the "HEAD" method on a REST service, and verify the returned content is image before returning the header part.
RestHeadJSON
TID
Perform the "HEAD" method on a REST service, and verify the returned content is json before returning the header part.
RestHeadScript
TID
Perform the "HEAD" method on a REST service, and verify the returned content is javascript before returning the header part.
RestHeadText
TID
Perform the "HEAD" method on a REST service, and verify the returned content is text before returning the header part.
RestHeadXML
TID
Perform the "HEAD" method on a REST service, and verify the returned content is xml before returning the header part.
RestPatchBinary
RestPatchCSS
RestPatchCustom
RestPatchHTML
RestPatchImage
RestPatchJSON
RestPatchScript
RestPatchText
RestPatchXML
TID
Perform the "PATCH" method on a REST service, and verify the returned status code is 200 or 204.
RestPostBinary
RestPostCSS
RestPostCustom
RestPostHTML
RestPostImage
RestPostJSON
RestPostScript
RestPostText
RestPostXML
TID
Perform the "POST" method on a REST service, and verify the returned status code is 201 ("created").
RestPutBinary
Put binary content. Not implemented yet.
RestPutCSS
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutCustom
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutHTML
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutImage
Put image content. Not implemented yet.
RestPutJSON
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutScript
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutText
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestPutXML
TID
Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.
RestRequest
TID
Perform an HTTP method on a REST service.
RestStartServiceSession
TID
Start a session for a REST service.

TIDRestFunctions::RestDeleteBinary

Delete binary content. Not implemented yet.


Fields: [ ]=Optional with Default Value
    Examples:
    [How To Read This Reference]

    TIDRestFunctions::RestDeleteCSS

    Delete css content. Not implemented yet.


    Fields: [ ]=Optional with Default Value
      Examples:
      [How To Read This Reference]

      TIDRestFunctions::RestDeleteCustom
      TID

      Perform the "DELETE" method on a REST service with headers defined by user.

      This action will send the "DELETE" method with Headers defined by user.

      If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
      Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



      Fields: [ ]=Optional with Default Value
      1. relativeURI
        The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

        This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

      2. responseIdVar
        The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

        The ID is generated internally, and it is used to get the Response Object from the internal Map.

      3. [ body = ]
        The body to send with this REST request.

        It can be
        1. a literal text string for something simple.
        2. a project-relative or full path to a file of larger body content in the proper format.
        The body's content-type could be defined in the headers.


      4. [ headers = ]
        The custom headers to be included in this REST request.

        It can be
        1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
        2. a map item holding the literal-string or header-file-path.
        3. a project-relative-path or full-path to a file holding the literal header string.


      5. [ authentication = ]
        The custom authentication/authorization information.

        It can be
        • a project-relative-path or full-path to a file holding the authentication/authorization information.
        • a map item holding the auth-file-path.
        This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
        and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
        will still be taken in account if no custom auth information is specified.


      Examples:
      • T, SAFSREST, ServiceIdItem, RestDeleteCustom, "relativeURL", "ResponseIDVariable", , customHeader

        Within a session, execute a DELETE method on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL", the method will be requested with custom header defined by map item 'customHeader'


        The item "ServiceIdItem" and "customHeader" MUST be defined in the map such as:
        [SAFSREST]
        ServiceIdItem=ServiceSession001
        customHeader=Accept : application/octet-stream

        The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


      • T, SAFSREST, ServiceIdItemNonExist, RestDeleteCustom, "http://www.service.com/relativeURL/", "ResponseIDVariable", , "rest\customHeader.txt"

        Without session, execute a DELETE method on REST service URL "http://www.service.com/relativeURL/".


        The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
        [SAFSREST]
        ServiceIdItemNonExist=

        This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The file "<project>\rest\customHeader.txt" holds the header information with which to make request. The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


      [How To Read This Reference]

      TIDRestFunctions::RestDeleteHTML



      Fields: [ ]=Optional with Default Value
        Examples:
        [How To Read This Reference]

        TIDRestFunctions::RestDeleteImage

        Delete image content. Not implemented yet.


        Fields: [ ]=Optional with Default Value
          Examples:
          [How To Read This Reference]

          TIDRestFunctions::RestDeleteJSON

          Delete json content. Not implemented yet.


          Fields: [ ]=Optional with Default Value
            Examples:
            [How To Read This Reference]

            TIDRestFunctions::RestDeleteScript

            Delete javascript content. Not implemented yet.


            Fields: [ ]=Optional with Default Value
              Examples:
              [How To Read This Reference]

              TIDRestFunctions::RestDeleteText

              Delete text content. Not implemented yet.


              Fields: [ ]=Optional with Default Value
                Examples:
                [How To Read This Reference]

                TIDRestFunctions::RestDeleteXML

                Delete xml content. Not implemented yet.


                Fields: [ ]=Optional with Default Value
                  Examples:
                  [How To Read This Reference]

                  TIDRestFunctions::RestEndServiceSession
                  TID

                  Stop a session for a REST service.

                  Stop a session for a REST service.

                  Fields: [ ]=Optional with Default Value
                    Examples:
                    • T, SAFSREST, BayerSessionID, RestEndServiceSession

                      Stop a session identified by value of map item BayerSessionID for a REST service.


                      Stop a session identified by value of map item BayerSessionID for a REST service.



                    [How To Read This Reference]

                    TIDRestFunctions::RestGetBinary
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is binary before returning it.

                    This action will send the "GET" method with Headers containing "Accept : application/octet-stream". It only tells the server what type of content is expected, and it is not guarantee that the server will return it. This action will verify the reponse's headers containing "Content-Type: application/octet-stream" to make sure the returned content is binary.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information by keyword's parameter.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The "response ID" is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, BayerServiceIdItem, RestGetBinary, "sqlrest/CUSTOMER/", "BayerCustomerResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : application/octet-stream") on REST service URL formed by prepending the base-URL to the relative-URI "sqlrest/CUSTOMER/"


                      The item "BayerServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      BayerServiceIdItem=BayerServiceSession001

                      The session is identified by sessionID "BayerServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.thomas-bayer.com/", then the full REST Service URL is "http://www.thomas-bayer.com/sqlrest/CUSTOMER/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable BayerCustomerResponseIDVariable.


                    • T, SAFSREST, BayerServiceIdItemNonExist, RestGetBinary, "http://www.thomas-bayer.com/sqlrest/CUSTOMER/", "BayerCustomerResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : application/octet-stream") on REST service URL "http://www.thomas-bayer.com/sqlrest/CUSTOMER/".


                      The item "BayerServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      BayerServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided a full path URL "http://www.thomas-bayer.com/sqlrest/CUSTOMER/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable BayerCustomerResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetCSS
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is css before returning it.

                    This action will send the "GET" method with Headers containing "Accept : text/css". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetCSS, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : text/css") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetCSS, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : text/css") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetCustom
                    TID

                    Perform the "GET" method on a REST service with headers defined by user, and return the content.

                    This action will send the "GET" method with Headers defined by user.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. headers
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetCustom, "relativeURL", "ResponseIDVariable", , customHeader

                      Within a session, execute a GET method on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL", the method will be requested with custom header defined by map item 'customHeader'


                      The item "ServiceIdItem" and "customHeader" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001
                      customHeader=Accept : application/octet-stream

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetCustom, "http://www.service.com/relativeURL/", "ResponseIDVariable", , "rest\customHeader.txt"

                      Without session, execute a GET method on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The file "<project>\rest\customHeader.txt" holds the header information with which to make request. The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetHTML
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is html before returning it.

                    This action will send the "GET" method with Headers containing "Accept : text/html". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetCustom, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : text/html") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetCustom, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : text/html") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetImage
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is image before returning it.

                    This action will send the "GET" method with Headers containing "Accept : image". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetImage, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : image") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetImage, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : image") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetJSON
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is json before returning it.

                    This action will send the "GET" method with Headers containing "Accept : application/json". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetJSON, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : application/json") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetJSON, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : application/json") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetScript
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is javascript before returning it.

                    This action will send the "GET" method with Headers containing "Accept : application/javascript". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetScript, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : application/javascript") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetScript, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : application/javascript") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetText
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is text before returning it.

                    This action will send the "GET" method with Headers containing "Accept : text/plain". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetText, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : text/plain") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetText, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : text/plain") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestGetXML
                    TID

                    Perform the "GET" method on a REST service, and verify the returned content is xml before returning it.

                    This action will send the "GET" method with Headers containing "Accept : text/xml". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestGetXML, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a GET method (with Headers containing "Accept : text/xml") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestGetXML, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a GET method (with Headers containing "Accept : text/xml") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadBinary
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is binary before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : application/octet-stream". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadBinary, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : application/octet-stream") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadBinary, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : application/octet-stream") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadCSS
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is css before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : text/css". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadCSS, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : text/css") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadCSS, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : text/css") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadCustom
                    TID

                    Perform the "HEAD" method (with headers defined by user) on a REST service, and get back the header part.

                    This action will send the "HEAD" method with Headers defined by user. It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadCustom, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers defined by user) on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadCustom, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers defined by user) on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadHTML
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is html before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : text/html". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadHTML, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : text/html") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadHTML, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : text/html") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadImage
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is image before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : image". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadImage, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : image") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadImage, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : image") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadJSON
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is json before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : application/json". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadJSON, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : application/json") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadJSON, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : application/json") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadScript
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is javascript before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : application/javascript". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadScript, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : application/javascript") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadScript, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : application/javascript") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadText
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is text before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : text/plain". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadText, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : text/plain") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadText, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : text/plain") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestHeadXML
                    TID

                    Perform the "HEAD" method on a REST service, and verify the returned content is xml before returning the header part.

                    This action will send the "HEAD" method with Headers containing "Accept : text/xml". It only tells the server what type of content is expected, and it is not guarantee that the server will return it.

                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                    Fields: [ ]=Optional with Default Value
                    1. relativeURI
                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.

                    2. responseIdVar
                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                    3. [ body = ]
                      The body to send with this REST request.

                      It can be
                      1. a literal text string for something simple.
                      2. a project-relative or full path to a file of larger body content in the proper format.
                      The body's content-type could be defined in the headers.


                    4. [ headers = ]
                      The custom headers to be included in this REST request.

                      It can be
                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                      2. a map item holding the literal-string or header-file-path.
                      3. a project-relative-path or full-path to a file holding the literal header string.


                    5. [ authentication = ]
                      The custom authentication/authorization information.

                      It can be
                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                      • a map item holding the auth-file-path.
                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                      will still be taken in account if no custom auth information is specified.


                    Examples:
                    • T, SAFSREST, ServiceIdItem, RestHeadXML, "relativeURL", "ResponseIDVariable"

                      Within a session, execute a HEAD method (with Headers containing "Accept : text/xml") on REST service URL formed by prepending the base-URL to the relative-URI "relativeURL"


                      The item "ServiceIdItem" MUST be defined in the map such as:
                      [SAFSREST]
                      ServiceIdItem=ServiceSession001

                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    • T, SAFSREST, ServiceIdItemNonExist, RestHeadXML, "http://www.service.com/relativeURL/", "ResponseIDVariable"

                      Without session, execute a HEAD method (with Headers containing "Accept : text/xml") on REST service URL "http://www.service.com/relativeURL/".


                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                      [SAFSREST]
                      ServiceIdItemNonExist=

                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/relativeURL/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                    [How To Read This Reference]

                    TIDRestFunctions::RestPatchBinary



                    Fields: [ ]=Optional with Default Value
                      Examples:
                      [How To Read This Reference]

                      TIDRestFunctions::RestPatchCSS



                      Fields: [ ]=Optional with Default Value
                        Examples:
                        [How To Read This Reference]

                        TIDRestFunctions::RestPatchCustom



                        Fields: [ ]=Optional with Default Value
                          Examples:
                          [How To Read This Reference]

                          TIDRestFunctions::RestPatchHTML



                          Fields: [ ]=Optional with Default Value
                            Examples:
                            [How To Read This Reference]

                            TIDRestFunctions::RestPatchImage



                            Fields: [ ]=Optional with Default Value
                              Examples:
                              [How To Read This Reference]

                              TIDRestFunctions::RestPatchJSON



                              Fields: [ ]=Optional with Default Value
                                Examples:
                                [How To Read This Reference]

                                TIDRestFunctions::RestPatchScript



                                Fields: [ ]=Optional with Default Value
                                  Examples:
                                  [How To Read This Reference]

                                  TIDRestFunctions::RestPatchText



                                  Fields: [ ]=Optional with Default Value
                                    Examples:
                                    [How To Read This Reference]

                                    TIDRestFunctions::RestPatchXML
                                    TID

                                    Perform the "PATCH" method on a REST service, and verify the returned status code is 200 or 204.

                                    This action will send the "PATCH" method with Headers containing "Content-Type : text/xml".

                                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                    Fields: [ ]=Optional with Default Value
                                    1. relativeURI
                                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                      This URL should point to an entity to be updated, such as "users/{id}".


                                    2. responseIdVar
                                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                    3. [ body = ]
                                      The body to send with this REST request.

                                      It can be
                                      1. a literal text string for something simple.
                                      2. a project-relative or full path to a file of larger body content in the proper format.
                                      The content should be a part of the entity indicated by the parameter 'relativeURI'.


                                    4. [ headers = ]
                                      The custom headers to be included in this REST request.

                                      It can be
                                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                      2. a map item holding the literal-string or header-file-path.
                                      3. a project-relative-path or full-path to a file holding the literal header string.


                                    5. [ authentication = ]
                                      The custom authentication/authorization information.

                                      It can be
                                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                      • a map item holding the auth-file-path.
                                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                      will still be taken in account if no custom auth information is specified.


                                    Examples:
                                    • T, SAFSREST, ServiceIdItem, RestPatchXML, "users/1", "ResponseIDVariable", partialUserEntity.xml

                                      Within a session, execute a PATCH method (with Headers containing "Content-Type : text/xml") on REST service URL formed by prepending the base-URL to the relative-URI "users/1"

                                      the parameter partialUserEntity.xml is the file under the test project, and it contains the xml content (a part of the user entity) to send as body part with PATCH command


                                      The item "ServiceIdItem" MUST be defined in the map such as:
                                      [SAFSREST]
                                      ServiceIdItem=ServiceSession001

                                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                    • T, SAFSREST, ServiceIdItemNonExist, RestPatchXML, "http://www.service.com/users/1/", "ResponseIDVariable", partialUserEntity.xml

                                      Without session, execute a PATCH method (with Headers containing "Content-Type : text/xml") on REST service URL "http://www.service.com/users/1/".

                                      the parameter partialUserEntity.xml is the file under the test project, and it contains the xml content (a part of the user entity) to send as body part with PATCH command


                                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                      [SAFSREST]
                                      ServiceIdItemNonExist=

                                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                    [How To Read This Reference]

                                    TIDRestFunctions::RestPostBinary



                                    Fields: [ ]=Optional with Default Value
                                      Examples:
                                      [How To Read This Reference]

                                      TIDRestFunctions::RestPostCSS



                                      Fields: [ ]=Optional with Default Value
                                        Examples:
                                        [How To Read This Reference]

                                        TIDRestFunctions::RestPostCustom



                                        Fields: [ ]=Optional with Default Value
                                          Examples:
                                          [How To Read This Reference]

                                          TIDRestFunctions::RestPostHTML



                                          Fields: [ ]=Optional with Default Value
                                            Examples:
                                            [How To Read This Reference]

                                            TIDRestFunctions::RestPostImage



                                            Fields: [ ]=Optional with Default Value
                                              Examples:
                                              [How To Read This Reference]

                                              TIDRestFunctions::RestPostJSON



                                              Fields: [ ]=Optional with Default Value
                                                Examples:
                                                [How To Read This Reference]

                                                TIDRestFunctions::RestPostScript



                                                Fields: [ ]=Optional with Default Value
                                                  Examples:
                                                  [How To Read This Reference]

                                                  TIDRestFunctions::RestPostText



                                                  Fields: [ ]=Optional with Default Value
                                                    Examples:
                                                    [How To Read This Reference]

                                                    TIDRestFunctions::RestPostXML
                                                    TID

                                                    Perform the "POST" method on a REST service, and verify the returned status code is 201 ("created").

                                                    This action will send the "POST" method with Headers containing "Content-Type : text/xml".

                                                    If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                    Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                    Fields: [ ]=Optional with Default Value
                                                    1. relativeURI
                                                      The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                      This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                      This URL should point to a collection, such as "users/".


                                                    2. responseIdVar
                                                      The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                      The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                    3. [ body = ]
                                                      The body to send with this REST request.

                                                      It can be
                                                      1. a literal text string for something simple.
                                                      2. a project-relative or full path to a file of larger body content in the proper format.
                                                      The content should be the ENTIRETY of the entity of collection indicated by the parameter 'relativeURI'.


                                                    4. [ headers = ]
                                                      The custom headers to be included in this REST request.

                                                      It can be
                                                      1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                      2. a map item holding the literal-string or header-file-path.
                                                      3. a project-relative-path or full-path to a file holding the literal header string.


                                                    5. [ authentication = ]
                                                      The custom authentication/authorization information.

                                                      It can be
                                                      • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                      • a map item holding the auth-file-path.
                                                      This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                      and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                      will still be taken in account if no custom auth information is specified.


                                                    Examples:
                                                    • T, SAFSREST, ServiceIdItem, RestPostXML, "users/", "ResponseIDVariable", wholeUserEntity.xml

                                                      Within a session, execute a POST method (with Headers containing "Content-Type : text/xml") on REST service URL formed by prepending the base-URL to the relative-URI "users/"

                                                      the parameter wholeUserEntity.xml is the file under the test project, and it contains the xml content (the entirety of entity user) to send as body part with POST command


                                                      The item "ServiceIdItem" MUST be defined in the map such as:
                                                      [SAFSREST]
                                                      ServiceIdItem=ServiceSession001

                                                      The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                    • T, SAFSREST, ServiceIdItemNonExist, RestPostXML, "http://www.service.com/users/", "ResponseIDVariable", wholeUserEntity.xml

                                                      Without session, execute a POST method (with Headers containing "Content-Type : text/xml") on REST service URL "http://www.service.com/users/".

                                                      the parameter wholeUserEntity.xml is the file under the test project, and it contains the xml content (the entirety of entity user) to send as body part with POST command


                                                      The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                      [SAFSREST]
                                                      ServiceIdItemNonExist=

                                                      This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                    [How To Read This Reference]

                                                    TIDRestFunctions::RestPutBinary

                                                    Put binary content. Not implemented yet.


                                                    Fields: [ ]=Optional with Default Value
                                                      Examples:
                                                      [How To Read This Reference]

                                                      TIDRestFunctions::RestPutCSS
                                                      TID

                                                      Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                      This action will send the "PUT" method with Headers containing "Content-Type : text/css".

                                                      If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                      Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                      Fields: [ ]=Optional with Default Value
                                                      1. relativeURI
                                                        The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                        This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                        This URL should point to an entity to be updated, such as "cssContents/{id}".


                                                      2. responseIdVar
                                                        The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                        The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                      3. [ body = ]
                                                        The body to send with this REST request.

                                                        It can be
                                                        1. a literal text string for something simple.
                                                        2. a project-relative or full path to a file of larger body content in the proper format.
                                                        The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                      4. [ headers = ]
                                                        The custom headers to be included in this REST request.

                                                        It can be
                                                        1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                        2. a map item holding the literal-string or header-file-path.
                                                        3. a project-relative-path or full-path to a file holding the literal header string.


                                                      5. [ authentication = ]
                                                        The custom authentication/authorization information.

                                                        It can be
                                                        • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                        • a map item holding the auth-file-path.
                                                        This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                        and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                        will still be taken in account if no custom auth information is specified.


                                                      Examples:
                                                      • T, SAFSREST, ServiceIdItem, RestPutCSS, "cssContents/1", "ResponseIDVariable", wholeUserStyleEntity.css

                                                        Within a session, execute a PUT method (with Headers containing "Content-Type : text/css") on REST service URL formed by prepending the base-URL to the relative-URI "cssContents/1"

                                                        the parameter wholeUserStyleEntity.css is the file under the test project, and it contains the css content (the entirety of entity user's style) to send as body part with PUT command


                                                        The item "ServiceIdItem" MUST be defined in the map such as:
                                                        [SAFSREST]
                                                        ServiceIdItem=ServiceSession001

                                                        The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/cssContents/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      • T, SAFSREST, ServiceIdItemNonExist, RestPutCSS, "http://www.service.com/cssContents/1/", "ResponseIDVariable", wholeUserStyleEntity.css

                                                        Without session, execute a PUT method (with Headers containing "Content-Type : text/css") on REST service URL "http://www.service.com/cssContents/1/".

                                                        the parameter wholeUserStyleEntity.css is the file under the test project, and it contains the css content (the entirety of entity user's style) to send as body part with PUT command


                                                        The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                        [SAFSREST]
                                                        ServiceIdItemNonExist=

                                                        This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/cssContents/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      [How To Read This Reference]

                                                      TIDRestFunctions::RestPutCustom
                                                      TID

                                                      Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                      This action will send the "PUT" method with Headers defined by user.

                                                      If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                      Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                      Fields: [ ]=Optional with Default Value
                                                      1. relativeURI
                                                        The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                        This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                        This URL should point to an entity to be updated, such as "entities/{id}".


                                                      2. responseIdVar
                                                        The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                        The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                      3. [ body = ]
                                                        The body to send with this REST request.

                                                        It can be
                                                        1. a literal text string for something simple.
                                                        2. a project-relative or full path to a file of larger body content in the proper format.
                                                        The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                      4. [ headers = ]
                                                        The custom headers to be included in this REST request.

                                                        It can be
                                                        1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                        2. a map item holding the literal-string or header-file-path.
                                                        3. a project-relative-path or full-path to a file holding the literal header string.


                                                      5. [ authentication = ]
                                                        The custom authentication/authorization information.

                                                        It can be
                                                        • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                        • a map item holding the auth-file-path.
                                                        This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                        and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                        will still be taken in account if no custom auth information is specified.


                                                      Examples:
                                                      • T, SAFSREST, ServiceIdItem, RestPutCustom, "entities/1", "ResponseIDVariable", "entityFile", "customHeader.txt"

                                                        Within a session, execute a PUT method (with Headers defined in project-relative file "customHeader.txt") on REST service URL formed by prepending the base-URL to the relative-URI "entities/1"

                                                        the parameter "entityFile" is the file under the test project, and it contains the some content (the entirety of an entity) to send as body part with PUT command


                                                        The item "ServiceIdItem" MUST be defined in the map such as:
                                                        [SAFSREST]
                                                        ServiceIdItem=ServiceSession001

                                                        The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/entities/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      • T, SAFSREST, ServiceIdItemNonExist, RestPutCustom, "http://www.service.com/entities/1/", "ResponseIDVariable", "entityFile", "customHeader.txt"

                                                        Without session, execute a PUT method (with Headers defined in project-relative file "customHeader.txt") on REST service URL "http://www.service.com/entities/1/".

                                                        the parameter "entityFile" is the file under the test project, and it contains the some content (the entirety of an entity) to send as body part with PUT command


                                                        The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                        [SAFSREST]
                                                        ServiceIdItemNonExist=

                                                        This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/entities/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      [How To Read This Reference]

                                                      TIDRestFunctions::RestPutHTML
                                                      TID

                                                      Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                      This action will send the "PUT" method with Headers containing "Content-Type : text/html".

                                                      If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                      Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                      Fields: [ ]=Optional with Default Value
                                                      1. relativeURI
                                                        The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                        This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                        This URL should point to an entity to be updated, such as "htmlContents/{id}".


                                                      2. responseIdVar
                                                        The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                        The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                      3. [ body = ]
                                                        The body to send with this REST request.

                                                        It can be
                                                        1. a literal text string for something simple.
                                                        2. a project-relative or full path to a file of larger body content in the proper format.
                                                        The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                      4. [ headers = ]
                                                        The custom headers to be included in this REST request.

                                                        It can be
                                                        1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                        2. a map item holding the literal-string or header-file-path.
                                                        3. a project-relative-path or full-path to a file holding the literal header string.


                                                      5. [ authentication = ]
                                                        The custom authentication/authorization information.

                                                        It can be
                                                        • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                        • a map item holding the auth-file-path.
                                                        This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                        and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                        will still be taken in account if no custom auth information is specified.


                                                      Examples:
                                                      • T, SAFSREST, ServiceIdItem, RestPutHTML, "htmlContents/1", "ResponseIDVariable", wholeUserEntity.html

                                                        Within a session, execute a PUT method (with Headers containing "Content-Type : text/html") on REST service URL formed by prepending the base-URL to the relative-URI "htmlContents/1"

                                                        the parameter wholeUserEntity.html is the file under the test project, and it contains the html content (the entirety of entity user) to send as body part with PUT command


                                                        The item "ServiceIdItem" MUST be defined in the map such as:
                                                        [SAFSREST]
                                                        ServiceIdItem=ServiceSession001

                                                        The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/htmlContents/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      • T, SAFSREST, ServiceIdItemNonExist, RestPutHTML, "http://www.service.com/htmlContents/1/", "ResponseIDVariable", wholeUserEntity.html

                                                        Without session, execute a PUT method (with Headers containing "Content-Type : text/html") on REST service URL "http://www.service.com/htmlContents/1/".

                                                        the parameter wholeUserEntity.html is the file under the test project, and it contains the html content (the entirety of entity user) to send as body part with PUT command


                                                        The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                        [SAFSREST]
                                                        ServiceIdItemNonExist=

                                                        This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/htmlContents/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                      [How To Read This Reference]

                                                      TIDRestFunctions::RestPutImage

                                                      Put image content. Not implemented yet.


                                                      Fields: [ ]=Optional with Default Value
                                                        Examples:
                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestPutJSON
                                                        TID

                                                        Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                        This action will send the "PUT" method with Headers containing "Content-Type : application/json".

                                                        If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                        Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                        Fields: [ ]=Optional with Default Value
                                                        1. relativeURI
                                                          The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                          This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                          This URL should point to an entity to be updated, such as "users/{id}".


                                                        2. responseIdVar
                                                          The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                          The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                        3. [ body = ]
                                                          The body to send with this REST request.

                                                          It can be
                                                          1. a literal text string for something simple.
                                                          2. a project-relative or full path to a file of larger body content in the proper format.
                                                          The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                        4. [ headers = ]
                                                          The custom headers to be included in this REST request.

                                                          It can be
                                                          1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                          2. a map item holding the literal-string or header-file-path.
                                                          3. a project-relative-path or full-path to a file holding the literal header string.


                                                        5. [ authentication = ]
                                                          The custom authentication/authorization information.

                                                          It can be
                                                          • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                          • a map item holding the auth-file-path.
                                                          This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                          and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                          will still be taken in account if no custom auth information is specified.


                                                        Examples:
                                                        • T, SAFSREST, ServiceIdItem, RestPutJSON, "users/1", "ResponseIDVariable", wholeUserEntity.json

                                                          Within a session, execute a PUT method (with Headers containing "Content-Type : application/json") on REST service URL formed by prepending the base-URL to the relative-URI "users/1"

                                                          the parameter wholeUserEntity.json is the file under the test project, and it contains the json content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        • T, SAFSREST, ServiceIdItemNonExist, RestPutJSON, "http://www.service.com/users/1/", "ResponseIDVariable", wholeUserEntity.json

                                                          Without session, execute a PUT method (with Headers containing "Content-Type : application/json") on REST service URL "http://www.service.com/users/1/".

                                                          the parameter wholeUserEntity.json is the file under the test project, and it contains the json content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                          [SAFSREST]
                                                          ServiceIdItemNonExist=

                                                          This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestPutScript
                                                        TID

                                                        Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                        This action will send the "PUT" method with Headers containing "Content-Type : application/javascript".

                                                        If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                        Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                        Fields: [ ]=Optional with Default Value
                                                        1. relativeURI
                                                          The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                          This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                          This URL should point to an entity to be updated, such as "users/{id}".


                                                        2. responseIdVar
                                                          The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                          The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                        3. [ body = ]
                                                          The body to send with this REST request.

                                                          It can be
                                                          1. a literal text string for something simple.
                                                          2. a project-relative or full path to a file of larger body content in the proper format.
                                                          The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                        4. [ headers = ]
                                                          The custom headers to be included in this REST request.

                                                          It can be
                                                          1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                          2. a map item holding the literal-string or header-file-path.
                                                          3. a project-relative-path or full-path to a file holding the literal header string.


                                                        5. [ authentication = ]
                                                          The custom authentication/authorization information.

                                                          It can be
                                                          • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                          • a map item holding the auth-file-path.
                                                          This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                          and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                          will still be taken in account if no custom auth information is specified.


                                                        Examples:
                                                        • T, SAFSREST, ServiceIdItem, RestPutText, "users/1", "ResponseIDVariable", wholeUserEntity.txt

                                                          Within a session, execute a PUT method (with Headers containing "Content-Type : application/javascript") on REST service URL formed by prepending the base-URL to the relative-URI "users/1"

                                                          the parameter wholeUserEntity.txt is the file under the test project, and it contains the text content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        • T, SAFSREST, ServiceIdItemNonExist, RestPutText, "http://www.service.com/users/1/", "ResponseIDVariable", wholeUserEntity.txt

                                                          Without session, execute a PUT method (with Headers containing "Content-Type : application/javascript") on REST service URL "http://www.service.com/users/1/".

                                                          the parameter wholeUserEntity.txt is the file under the test project, and it contains the text content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                          [SAFSREST]
                                                          ServiceIdItemNonExist=

                                                          This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestPutText
                                                        TID

                                                        Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                        This action will send the "PUT" method with Headers containing "Content-Type : text/plain".

                                                        If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                        Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                        Fields: [ ]=Optional with Default Value
                                                        1. relativeURI
                                                          The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                          This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                          This URL should point to an entity to be updated, such as "users/{id}".


                                                        2. responseIdVar
                                                          The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                          The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                        3. [ body = ]
                                                          The body to send with this REST request.

                                                          It can be
                                                          1. a literal text string for something simple.
                                                          2. a project-relative or full path to a file of larger body content in the proper format.
                                                          The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                        4. [ headers = ]
                                                          The custom headers to be included in this REST request.

                                                          It can be
                                                          1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                          2. a map item holding the literal-string or header-file-path.
                                                          3. a project-relative-path or full-path to a file holding the literal header string.


                                                        5. [ authentication = ]
                                                          The custom authentication/authorization information.

                                                          It can be
                                                          • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                          • a map item holding the auth-file-path.
                                                          This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                          and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                          will still be taken in account if no custom auth information is specified.


                                                        Examples:
                                                        • T, SAFSREST, ServiceIdItem, RestPutText, "users/1", "ResponseIDVariable", wholeUserEntity.txt

                                                          Within a session, execute a PUT method (with Headers containing "Content-Type : text/plain") on REST service URL formed by prepending the base-URL to the relative-URI "users/1"

                                                          the parameter wholeUserEntity.txt is the file under the test project, and it contains the text content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        • T, SAFSREST, ServiceIdItemNonExist, RestPutText, "http://www.service.com/users/1/", "ResponseIDVariable", wholeUserEntity.txt

                                                          Without session, execute a PUT method (with Headers containing "Content-Type : text/plain") on REST service URL "http://www.service.com/users/1/".

                                                          the parameter wholeUserEntity.txt is the file under the test project, and it contains the text content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                          [SAFSREST]
                                                          ServiceIdItemNonExist=

                                                          This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestPutXML
                                                        TID

                                                        Perform the "PUT" method on a REST service, and verify the returned status code is 201 ("created") or 200 or 204.

                                                        This action will send the "PUT" method with Headers containing "Content-Type : text/xml".

                                                        If the field SessionIDItem is provided in the map, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session.
                                                        Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.



                                                        Fields: [ ]=Optional with Default Value
                                                        1. relativeURI
                                                          The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                          This is normally a relative URI (the base-URL is provided in a session). BUT it should be full path URL if the field SessionIDItem is not provided or invalid.
                                                          This URL should point to an entity to be updated, such as "users/{id}".


                                                        2. responseIdVar
                                                          The name of the variable holding "response ID", which is used by rest driver commands to verify/delete response.

                                                          The ID is generated internally, and it is used to get the Response Object from the internal Map.

                                                        3. [ body = ]
                                                          The body to send with this REST request.

                                                          It can be
                                                          1. a literal text string for something simple.
                                                          2. a project-relative or full path to a file of larger body content in the proper format.
                                                          The content should be the ENTIRETY of the entity indicated by the parameter 'relativeURI'.


                                                        4. [ headers = ]
                                                          The custom headers to be included in this REST request.

                                                          It can be
                                                          1. a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                          2. a map item holding the literal-string or header-file-path.
                                                          3. a project-relative-path or full-path to a file holding the literal header string.


                                                        5. [ authentication = ]
                                                          The custom authentication/authorization information.

                                                          It can be
                                                          • a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                          • a map item holding the auth-file-path.
                                                          This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                          and take effect only in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                          will still be taken in account if no custom auth information is specified.


                                                        Examples:
                                                        • T, SAFSREST, ServiceIdItem, RestPutXML, "users/1", "ResponseIDVariable", wholeUserEntity.xml

                                                          Within a session, execute a PUT method (with Headers containing "Content-Type : text/xml") on REST service URL formed by prepending the base-URL to the relative-URI "users/1"

                                                          the parameter wholeUserEntity.xml is the file under the test project, and it contains the xml content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          The session is identified by sessionID "ServiceSession001", according to which the base-URL is gotten. If the base-URL is "http://www.service.com/", then the full REST Service URL is "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        • T, SAFSREST, ServiceIdItemNonExist, RestPutXML, "http://www.service.com/users/1/", "ResponseIDVariable", wholeUserEntity.xml

                                                          Without session, execute a PUT method (with Headers containing "Content-Type : text/xml") on REST service URL "http://www.service.com/users/1/".

                                                          the parameter wholeUserEntity.xml is the file under the test project, and it contains the xml content (the entirety of entity user) to send as body part with PUT command


                                                          The item "ServiceIdItemNonExist" should NOT be defined, or defined with an empty value in the map:
                                                          [SAFSREST]
                                                          ServiceIdItemNonExist=

                                                          This action is handled as one-shot connection. The parameter "relativeURI" is provided as a full path URL "http://www.service.com/users/1/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.


                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestRequest
                                                        TID

                                                        Perform an HTTP method on a REST service.

                                                        If the test field SessionIDItem is provided, the keyword RestStartServiceSession SHOULD be executed before executing this action, which will be handled within a session. Otherwise, it will be considered as a one-shot connection, and NO RestStartServiceSession needs to be called and user may need to provide authentication information.

                                                        Fields: [ ]=Optional with Default Value
                                                        1. HTTPMethod
                                                          The HTTP method to execute.

                                                          It can be one of "GET" "DELETE" "POST" "PUT" "PATCH" "HEAD".

                                                        2. relativeURI
                                                          The relative URI combined with a base-URL (stored in a session) to form a REST service URL.

                                                          This is normally a relative URI as the base-URL is provided in a session. BUT it should be full path URL if the parameter sessionID is not provided.

                                                        3. responseIdVar
                                                          The name of the variable holding the ID (generated internally), which is used to get the Response Object from the internal Map.


                                                        4. [ body = ]
                                                          The body to send with this REST request.

                                                          The body could be a literal text string for something simple. The body could also be a project-relative or full path to a file of larger body content in the proper format.

                                                        5. [ headers = ]
                                                          The custom headers to be included in this REST request.

                                                          It can be a literal string, such as "If-Modified-Since: Sat, 29 OCT 1994 19:43:31 GMT".
                                                          It can also be a project-relative-path or full-path to a file holding the literal header string.
                                                          It can also be a map item holding the literal-string or header-file-path.


                                                        6. [ authentication = ]
                                                          The custom authentication/authorization information.

                                                          It can be a project-relative-path or full-path to a file holding the authentication/authorization information.
                                                          It can also be a map item holding the auth-file-path.
                                                          This custom authentication/authorization information will override the global settings (in .ini file or by VM parameter.)
                                                          and take effect in this keyword execution. In the next keyword execution, the global authentication/authorization setting
                                                          will still be taken in account if no custom auth information is specified.


                                                        Examples:
                                                        • T, SAFSREST, ServiceIdItem, RestRequest, GET, "sqlrest/PRODUCT/", "ResponseIDVariable", "", "Accept: text/xml"
                                                          Execute a GET method on REST service URL formed by prepending the base-URL to the relative-URI "sqlrest/PRODUCT/"

                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          It will GET XML content from the sever.

                                                          The base-URL is gotten according to sessionID "ServiceSession001" (assigned when executing keyword RestStartServiceSession). If it is "http://www.thomas-bayer.com/", then the full REST Service URL is "http://www.thomas-bayer.com/sqlrest/PRODUCT/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.



                                                        • T, SAFSREST, ServiceIdItem, RestRequest, PUT, "sqlrest/PRODUCT/61/", "ResponseIDVariable", "<resource><NAME>CarSeat</NAME><PRICE>125.00</PRICE></resource>", "Content-Type: text/xml"
                                                          Execute a PUT method on REST service URL formed by prepending the base-URL to the relative-URI "sqlrest/PRODUCT/61/"

                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItem=ServiceSession001

                                                          It will send XML body "<resource><NAME>CarSeat</NAME><PRICE>125.00</PRICE></resource>" to sever so that "product #61" will be created.

                                                          The base-URL is gotten according to sessionID "ServiceSession001" (assigned when executing keyword RestStartServiceSession). If it is "http://www.thomas-bayer.com/", then the full REST Service URL is "http://www.thomas-bayer.com/sqlrest/PRODUCT/61/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.



                                                        • T, SAFSREST, ServiceIdItemNonExist, RestRequest, PUT, "http://www.thomas-bayer.com/sqlrest/PRODUCT/61/", "ResponseIDVariable", "<resource><NAME>CarSeat</NAME><PRICE>125.00</PRICE></resource>", "Content-Type: text/xml"
                                                          Execute a PUT method on REST service URL "http://www.thomas-bayer.com/sqlrest/PRODUCT/61/".

                                                          The item "ServiceIdItem" MUST be defined in the map such as:
                                                          [SAFSREST]
                                                          ServiceIdItemNonExist=

                                                          It will send XML body "<resource><NAME>CarSeat</NAME><PRICE>125.00</PRICE></resource>" to sever so that "product #61" will be created.

                                                          The map item ServiceIdItemNonExist does NOT exist, this action is handled as one-shot connection. The parameter relativeURI is provided as a full path URL "http://www.thomas-bayer.com/sqlrest/PRODUCT/61/". The Response Object will be stored in an internal Map with a generated ID, which will be saved to a variable ResponseIDVariable.



                                                        [How To Read This Reference]

                                                        TIDRestFunctions::RestStartServiceSession
                                                        TID

                                                        Start a session for a REST service.

                                                        Currently the "base URL" and "authentication information" will be stored for the opened session.



                                                        Fields: [ ]=Optional with Default Value
                                                        1. baseURL
                                                          The base URL to be stored with a session.

                                                          This base URL will be prepended in front of a relative URI to form a REST service URL for the later invocation of other REST actions.

                                                        2. [ authentication = ]
                                                          The file holding authentication information to be used during this session.

                                                          Normally, the authentication information will be loaded from "JVM -D parameters", "Map", or global external file, those settings are considered to be global. This parameter can be used to alternate the authentication information, it will override the global settings.
                                                          It is normally provided as a file name holding the authentication information. The file is relative to the project's root directory, and it can contain sub directories.
                                                          If it is provided as NOAUTHENTICATION, then no authentication is needed during the session even the global settings are set.


                                                        Examples:
                                                        • T, SAFSREST, BayerSessionID, RestStartServiceSession, "http://www.thomas-bayer.com/"
                                                          Start a session for a REST service based on URL "http://www.thomas-bayer.com/".

                                                          This session will be assigned with ID as value of map item BayerSessionID under section SAFSREST.

                                                          This session will use the global authentication if exists.



                                                        • T, SAFSREST, BayerSessionID, RestStartServiceSession, "http://www.thomas-bayer.com/", "configure/simpleauth.xml"
                                                          Start a session for a REST service based on URL "http://www.thomas-bayer.com/", and this session will use authentication information stored in file <project>/configure/simpleauth.xml.

                                                          This session will be identified by ID, which is already defined by map-item BayerSessionID under section SAFSREST.

                                                          The file <project>/configure/simpleauth.xml contains authentication information, example as below:
                                                            <SimpleAuth classname="org.safs.auth.SimpleAuth">
                                                              <password>unitA123</password>
                                                              <userName>Mark</userName>
                                                            </SimpleAuth>
                                                          


                                                        • T, SAFSREST, BayerSessionID, RestStartServiceSession, "http://www.thomas-bayer.com/", "NOAUTHENTICATION"
                                                          Start a session for a REST service based on URL "http://www.thomas-bayer.com/".

                                                          This session will be assigned with ID as value of map item BayerSessionID under section SAFSREST.

                                                          This session will NOT use any authentication even if the global authentication exists.



                                                        [How To Read This Reference]