LiveDoc - smartrics/RestFixture GitHub Wiki

SuiteSetUp

 
Precompiled Libraries



variable defined: ns1=

variable defined: defns=




Import
smartrics.rest.fitnesse.fixture
smartrics.rest.test.fitnesse.fixture






script
Http Server Fixture
check is started

false
start server 9876
check is started

true



 
Configure the RestFixture with named configuration table of key value pairs
Read more aboutRestFixtureConfig






Table: Rest Fixture Config
http.client.connection.timeout

5000
http.client.use.new.http.uri.factory

false
restfixture.display.actual.on.right

true
restfixture.display.toggle.for.cells.larger.than

200
restfixture.default.headers

defHeader : 1

anotherDefHeader : 2
restfixture.xml.namespace.context

ns1alias=http://smartrics/ns1 

 defalias=http://smartrics/defns
restfixture.content.default.charset

UTF-8
restfixture.content.handlers.map

application/xml=XML

application/json=JSON

text/plain=TEXT

default=XML

application/x-javascript=JS

CollapseableContent

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


In the interest of readability, cells with large content can be rendered with a toggle on/off button.

The minimum length in characters of the cell, in order to enable the toggle button, is specified with the property

restfixture.display.toggle.for.cells.larger.than

If the value of the property is negative the toggle button will not be rendered.

Currently only large HTTP response content cells (if the actual value is displayed) are enabled for toggling.





Table: Rest Fixture 		http://localhost:9876
GET /resources/100

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 910

Server : Jetty(6.0.2)

/resource/type[text()=‘large content’]


expected


toggle actual

<resource>

   <name>giant bob</name>

   <type>large content</type>

   <address>

       <street>

            Regent Street

       </street>

       <number>

            12345

       </number>

   </address>

   <data>

       <part id=‘0’>

           <source href=‘http://en.wikipedia.org/wiki/Inferno_(Dante)’ />

           <content>

Inferno (Italian for ‘Hell’) is the first part of Dante Alighieri’s 14th-century epic poem Divine Comedy. 

It is followed by Purgatorio and Paradiso. It is an allegory telling of the journey of Dante through what is 

largely the medieval concept of Hell, guided by the Roman poet Virgil. In the poem, Hell is depicted as nine 

circles of suffering located within the Earth. Allegorically, the Divine Comedy represents the journey of the soultowards God, with the Inferno describing the recognition and rejection of sin.

           </content>

       </part>

   </data>

</resource>



actual

DeleteTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database



 
Note
You may not want to specify any expectation neither in the header cell nor in the body cell, as in the GET below






Table: Rest Fixture 		http://localhost:9876
DELETE /resources/0

204

 Server : Jetty(6.0.2)

no-body
GET /resources/0

404

 Content-Length : 0

Server : Jetty(6.0.2) 		no-body

FailingGetTest

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database



 
Rest requests with query string containing array parameters
A query string can contain parameter arrays and they are correctly handled by Rest Fixture.


To allow correct handling of array parameters a new configuration option must be set: http.client.use.new.http.uri.factory





Table: Rest Fixture Config 		withArrayParametersSupport
http.client.use.new.http.uri.factory

true






Table: Rest Fixture 		http://localhost:9876 withArrayParametersSupport
GET /resources/0?a0=2&a1=4

200

 Query-String : a0=2&a1=4

Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2) 		<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>

GetTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database



 
Notes
A GET request is performed on the resource whose URI is specified in the second cell.

The following cell indicate:

1) the expected return HTTP code,

2) a subset of headers – regular expressions are allowed

3) a list of XPaths to be executed in the body. Each XPath is run and it suceedes only if the result of the execution

returns at least one node






Table: Rest Fixture 		http://localhost:9876
GET /resources/0

200

Content-Length : [\d]+


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’] <br/>

 /resource/data[text()=‘an important message’]



expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual



 
Absolute resource paths
A GET (as all other verbs) accepts absolute resource paths.






Table: Rest Fixture 		http://localhost:9876
GET /resources/0

200

Content-Length : [\d]+


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’] <br/>

 /resource/data[text()=‘an important message’]



expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual


A GET request properly handles query strings. In this example the stub resource echoes the query string in a Query-String header





Table: Rest Fixture 		http://localhost:9876
GET /resources/0?param=echome&something=else&another=parameter

200

Content-Length : [\d]+

Query-String : param=echome&something=else&another=parameter 


expected


Query-String : param=echome&something=else&another=parameter

Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’] <br/>

 /resource/data[text()=‘an important message’]



expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual


Get a non existing resource should not find it


 
Note
Instead of XPaths you can specify ‘no-body’ if the operation is expected to return an empty body






Table: Rest Fixture 		http://localhost:9876
GET /resources/20

404

Content-Length : 0


expected


Content-Length : 0

Server : Jetty(6.0.2)


actual

no-body
GET /resources/20.json

404

Content-Length : 0


expected


Content-Length : 0

Server : Jetty(6.0.2)


actual

no-body



 
XPaths and namespaces
Namespaces are supported by declaring the alias/uri map in theRestFixtureConfig, using the key restfixture.xml.namespace.context (SeeSuiteSetup)






Table: Rest Fixture 		http://localhost:9876
GET /resources/0

200

Content-Length : [\d]+


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual



 /resource/nstag/ns1alias:number[text()=‘3’]



expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual



 
Json
Expectations can be asserted also in json format for responses whose content type is ‘application/json’ or ‘application/x-javascript’






Table: Rest Fixture 		http://localhost:9876
GET /resources/1.json

200

Content-Type : application/json;charset=ISO-8859-1


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 77

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’] <br/>

 /resource/data[text()=‘an important message’]



expected


{ “resource” : { “name” : “a funky name”, “data” : “an important message” } }


actual



 
Rest requests with query string containing array parameters
A query string can contain parameter arrays and they are correctly handled by Rest Fixture.


To allow correct handling of array parameters a new configuration option must be set: http.client.use.new.http.uri.factory





Table: Rest Fixture Config 		withArrayParametersSupport
http.client.use.new.http.uri.factory

true






Table: Rest Fixture 		http://localhost:9876 withArrayParametersSupport
GET /resources/0?a0=2&a1=4

200

 Query-String : a0=2&a1=4

Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2) 		<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>



 
Follow redirects setting
To allow redirects to be followed automatically or not the configuration paramerer
restfixture.requests.follow.redirects

needs to be set (defaults to true)







Table: Rest Fixture Config 		withFollowRedirect
restfixture.requests.follow.redirects

false






Table: Rest Fixture 		http://localhost:9876 withFollowRedirect
GET /resources/redirect/0

301

Location: /resources/0


expected


Location : /resources/0

Content-Length : 0

Server : Jetty(6.0.2)


actual

no-body






Table: Rest Fixture Config 		withFollowRedirect
restfixture.requests.follow.redirects

true






Table: Rest Fixture 		http://localhost:9876 withFollowRedirect
GET /resources/redirect/0

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2) 		<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


HeadTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


Head requests should return no-body but the headers list should match that of the equivalent GET operation.





Table: Rest Fixture 		http://localhost:9876
GET /resources/0

200

Content-Length : [\d+]


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual

 <resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>
let length header Content-Length:(.+) 183
let type header Content-Type:(.+) application/xml;charset=ISO-8859-1
HEAD /resources/0

200

Content-Length : %length%


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual

no-body
HEAD /resources/0

200

Content-Type: %type%


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual

no-body

JavascriptExpectations

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


Expectations in Javascript on responses with content type application/json



As of RestFixture Version 2, a javascript engine is embedded to allow expectations in Javascript on response body contents in JSON format.


 
XPaths and JSON
For backward compatibility XPath expressions are maintained and executed


After a successful response is received with content type “application/json” the expectation cell in a RestFixture[?]
row is


interpreted as a string with Javascript and executed within the context of the response body.





Table: Rest Fixture 		http://localhost:9876
setBody { “resource” : { “name” : “test post”, “data” : “some data” } }
POST /resources/

201

 Location : /resources/2

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 2


A variable <code>jsonbody</code> is defined holding the JSON in the response.

The test passes if the result of the evaluation of the cell is a boolean.





Table: Rest Fixture 		http://localhost:9876
GET /resources/2.json

200

Content-Type : application/json


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2)


actual



jsonbody.resource.name"test post" && jsonbody.resource.data“some data” 



expected


 { “resource” : { “name” : “test post”, “data” : “some data” } } 


actual


It is possible to specify multiple assertions, one for each line.

The test passes if each line evaluates to true.





Table: Rest Fixture 		http://localhost:9876
GET /resources/2.json

200

Content-Type : application/json


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2)


actual



jsonbody.resource.name.length >= 0 

jsonbody.resource.name.length < 1000

jsonbody.resource.name.length < jsonbody.resource.name.length+1



expected


 { “resource” : { “name” : “test post”, “data” : “some data” } } 


actual
let content js response.body  { “resource” : { “name” : “test post”, “data” : “some data” } } 






Table: Rest Fixture 		http://localhost:9876
setBody

%content%


expected


 { “resource” : { “name” : “test post”, “data” : “some data” } } 


actual
POST /resources/

201

 Location : /resources/3

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 3


In some cases may be useful to force evaluation of the expectation cell as a javascript block.

By embedding the <code>/* javascript */</code> comment, the whole expectation cell will be parsed and evaluated entirely using the javascript interpreter.





Table: Rest Fixture 		http://localhost:9876
GET /resources/3.json

200

Content-Type : application/json


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2)


actual



/ javascript /

var concat = jsonbody.resource.name  “ and ”  jsonbody.resource.data

concat==“test post and some data” 



expected


 { “resource” : { “name” : “test post”, “data” : “some data” } } 


actual
let content js response.body  { “resource” : { “name” : “test post”, “data” : “some data” } } 


LetTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


Usages of LET (See alsoPostTests
for more examples)


LET used to extract values from header, using regular expressions





Table: Rest Fixture 		http://localhost:9876
setBody

<resource><name>Bill</name><data>Some data on Bill</data></resource>


expected


<resource><name>Bill</name><data>Some data on Bill</data></resource>


actual
POST /resources/

201

 Location : /resources/2

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 2


The regex is applied to each header. On the first match the first group is extracted and

assigned as value to the label
id.

Labels are global and can be shared across rest fixture instances.

LET used to extract values from XML body via XPath

Values are re-usable across instances of RestFixture

Here follows an usage of the previously extracted
id.

This example also shows how to use let to extract data from the XML body of a response using XPath.





Table: Rest Fixture 		http://localhost:9876
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 68

Server : Jetty(6.0.2)



 /resource/name[text()=‘Bill’]<br/>

 /resource/data[text()=‘Some data on Bill’]



expected


<resource><name>Bill</name><data>Some data on Bill</data></resource>


actual
let name body /resource/name/text() Bill


…or from a JSON body





Table: Rest Fixture 		http://localhost:9876
GET /resources/1.json

200

Content-Type : application/json


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 77

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’]<br/>

 /resource/data[text()=‘an important message’]

 


expected


{ “resource” : { “name” : “a funky name”, “data” : “an important message” } }


actual
let name body /resource/name/text() a funky name



 
Note
Label values can be accessed from code using
new Variables().get(“labelname”);


LET resolves names from Fixture Symbol map if not found in the local map

LetTestActionFixture allows to get/set values in the Fixture Symbol map





script
smartrics.rest.test.fitnesse.fixture.LetTestActionFixture
symbolName resType
symbolValue /resources



 
Note
Look at the source code of this page to see that the resource URI

for the GET method below is defined as
%resType%/%id%






Table: Rest Fixture 		http://localhost:9876
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 68

Server : Jetty(6.0.2) 		<resource><name>Bill</name><data>Some data on Bill</data></resource>
let theName body /resource/name/text() Bill






script
smartrics.rest.test.fitnesse.fixture.LetTestActionFixture
symbolName theName
check symbolValue

Bill


Other fixtures can set a value in the symbol map with
Fixture.setSymbol.

The RestFixture[?]
can then pick them up


This fixture sets
symbolName=/resources…





script
smartrics.rest.test.fitnesse.fixture.LetTestActionFixture
symbolName aNameOfASymbol
symbolValue /resources


… then the value is used by the RestFixture





Table: Rest Fixture 		http://localhost:9876
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 68

Server : Jetty(6.0.2) 		<resource><name>Bill</name><data>Some data on Bill</data></resource>


LetTestsV2

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


LET can use now the full power of JavaScript to extract data from the last response parts. The additions

to support the new JavaScript extensions will not break the existing RestFixture API.

The JavaScript extensions can be used to process more effectively JSON
Content-Types.

LET can access the Fitnesse Symbols map to extract data previously stored

If the context of the let context is
js
the expression is evaluated as a javascript string. The value assigned


to the let label is the result of the evaluation of the content in the expression cell.

For example:





Table: Rest Fixture 		http://localhost:9876
let message js ‘Hello, World!’

Hello, World!
let sum js ‘2 + 5 = ’  (2  5)

2 + 5 = 7
let two_expressions js a=1;

‘a is ’ + a

a is 1
let json_expr js


json = {

    widget

        debug;“on”,

        window

            title;“Sample Konfabulator Widget”,

            name;“main_window”,

            width,

            height

        },

        image;

            src;“Images/Sun.png”,

            name;“sun1”,

            hOffset,

            vOffset,

            alignment;“center”

        },

        text

            data;“Click Here”,

            size,

            style;“bold”,

            name;“text1”,

            hOffset,

            vOffset,

            alignment;“center”,

            onMouseUp;“sun1.opacity = (sun1.opacity / 100) * 90;”

        }

    }

};

json.widget.image.src

Images/Sun.png


(Example courtesy ofhttp://json.org/example.html)

It’s also possible to access the FitNesse symbols map. The scope where expression is evaluated contains the

‘symbols’ object





Table: Rest Fixture 		http://localhost:9876
setBody

<resource><name>Bill</name><data>Some data on Bill</data></resource>


expected


<resource><name>Bill</name><data>Some data on Bill</data></resource>


actual
POST /resources/

201

 Location : /resources/2

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 2
let id_string js ‘The id is: ’ + symbols.get(‘id’)

The id is: 2


The scope also contains the ‘response’ object, populated with the data from the last Rest response executed

For example





Table: Rest Fixture 		http://localhost:9876
GET /resources/1

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 77

Server : Jetty(6.0.2) 		{ “resource” : { “name” : “a funky name”, “data” : “an important message” } }
let body_value js response.body { “resource” : { “name” : “a funky name”, “data” : “an important message” } }
setBody

<resource><name>Bill</name><data>Some data on Bill</data></resource>


expected


<resource><name>Bill</name><data>Some data on Bill</data></resource>


actual
POST /resources/

201

 Location : /resources/3

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let status_code_value js response.statusCode 201
let status_text_value js response.statusText Created
let c_len js response.header0(‘Content-Length’)

0
let loc_again js response.header(‘Location’, 0) /resources/3
let h_size js response.headerListSize(‘Location’)

1
let all_h_size js response.headersSize() 3


A particoular case is when the response is JSON (Content-Type : application/json). In such case, the property
jsonbody

contains the JSON object that can be accessed using the dot notation. For example





Table: Rest Fixture 		http://localhost:9876
GET /resources/1.json

200

 Content-Type : application/json;charset=ISO-8859-1

Content-Length : 77

Server : Jetty(6.0.2) 		{ “resource” : { “name” : “a funky name”, “data” : “an important message” } }
let body_value js response.jsonbody [object Object]
let body_value js response.jsonbody.resource.name

a funky name


OptionsTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


Options requests are supported too:





Table: Rest Fixture 		http://localhost:9876
OPTIONS /resources/0

200

Allow:.+

Content-Length : 0


expected


Allow : GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS

Content-Length : 0

Server : Jetty(6.0.2)


actual

no-body

OverrideContentHandlers

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


RestFixture uses three content handlers to parse and set expectations used to verify the behaviour of HTTP calls.

These are the handlers currently available:



  • XML
    interprets the body as an xml string and allows XPath expressions as expectations on that content

  • JSON
    interprets the body as a JSON string and allows expectations to be written in JavaScript
    [?].

  • TEXT
    interprets the body as a string and allows regular expression expectations.


These are the defaults


  • default=XML

  • application/xml=XML

  • application/json=JSON

  • text/plain=TEXT



 
Note: unrecognised content types.
Content types not recogised will be mapped to the default content handler (XML).


For example, XML handler is used for for content types of application/xml; hence XPaths can be used to set expectations:





Table: Rest Fixture 		http://localhost:9876
GET /resources/0

200

Content-Type : application/xml;.+


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘a funky name’] <br/>

 /resource/data[text()=‘an important message’]



expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual


Bespoke mapping can be defined in the config using the config key
restfixture.content.handlers.map





Table: Rest Fixture Config 		overridesContentHandlerConfig
restfixture.content.handlers.map



application/xml=TEXT






Table: Rest Fixture 		http://localhost:9876 overridesContentHandlerConfig
GET /resources/0

200

Content-Type : application/xml;.+


expected


Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 183

Server : Jetty(6.0.2)


actual

<resource>[\s.]<name>a funky name</name>[\s\w\d<>/=\:’.]</resource>[\s]*


expected


<resource>

    <name>a funky name</name>

    <data>an important message</data>

    <nstag xmlns:ns1=‘http://smartrics/ns1’>

        <ns1:number>3</ns1:number>

    </nstag>

</resource>


actual


PostTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


Posting an XML should create a resource


 
Note
You set the body for the POST operation with the setBody.

Here you can see how
let
is used. The first cell is the

label
of the variable.


The follwoing cell indicates where to get the data from. That is either the
header
or the body of the last successful HTTP response


Then the expression to extract the value to be assigned to he variable. For
header
it has to be a regular expression, for body it


has to be an XPath whose execution must return a String node.






Table: Rest Fixture 		http://localhost:9876
setBody

<resource><name>test post</name><data>some data</data></resource>


expected


<resource><name>test post</name><data>some data</data></resource>


actual
POST /resources

201

 Location : /resources/2

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 2



 
Note
Variables are global: here the GET op is executed on an URI containing
%id%
where the label ‘id’ is defined in the test above.


The test succeedes only if the resulting XPath match the XML used for the creation of the resource.

You can also put variables in the expected result

The subsequent
let
operation shows how to use XPaths in the body.



Label values can be accessed from code using
new Variables().get(“labelname”);



 
Note on fit.Fixture symbol map
Labels are implemented on top of the Fitnesse symbols map. So every label set via RestFixture is accessible via
fit.Fixture.getSymbol().


If a label starts with $, the $ is ignored.






Table: Rest Fixture 		http://localhost:9876
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2)



 /resource/name[text()=‘test post’]<br/>

 /resource/data[text()=‘some data’]



expected


<resource><name>test post</name><data>some data</data></resource>


actual
let name body /resource/name/text() test post
let $symName body /resource/name/text() test post


Labels that are set to null are rendered using the default value for null, e.g. the string “null”





Table: Rest Fixture 		http://localhost:9876
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2) 		<resource><name>test post</name><data>some data</data></resource>
let thisIsNull body /resource/somewhereelse/text()
comment this is null: ‘null’


Albeit, the value can be overridden





Table: Rest Fixture Config 		withBespokeNullRepresentation
restfixture.null.value.representation






Table: Rest Fixture 		http://localhost:9876 withBespokeNullRepresentation
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2) 		<resource><name>test post</name><data>some data</data></resource>
let thisIsNull body /resource/somewhereelse/text()
comment this is null: ’’






Table: Rest Fixture Config 		withBespokeNullRepresentation
restfixture.null.value.representation

NIL






Table: Rest Fixture 		http://localhost:9876 withBespokeNullRepresentation
GET /resources/2

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2) 		<resource><name>test post</name><data>some data</data></resource>
let thisIsNull body /resource/somewhereelse/text()
comment this is null: ‘NIL’



 
Json
Expectations can be asserted also in json format for responses whose content type is ‘application/json’

Variables may be substitued in the expected result






Table: Rest Fixture 		http://localhost:9876
setBody { “resource” : { “name” : “test post”, “data” : “some data” } }
POST /resources/

201

 Location : /resources/3

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 3






Table: Rest Fixture 		http://localhost:9876
GET /resources/3.json

200

Content-Type : application/json


expected


Content-Type : application/json;charset=ISO-8859-1

Content-Length : 65

Server : Jetty(6.0.2)


actual



  /resource/name[text()=‘test post’] <br/>

  /resource/data[text()=‘some data’]



expected


 { “resource” : { “name” : “test post”, “data” : “some data” } } 


actual



 
File uploads
Use the multipartFile property to upload files to a server






script
smartrics.rest.test.fitnesse.fixture.FileUtilFixture
content { “resource” : { “name” : “test post”, “data” : “some data” } }
name target/live-docs-temp/tempfile
check create

true
check exists

true






Table: Rest Fixture 		http://localhost:9876
setMultipartFileName target/live-docs-temp/tempfile
POST /resources/

200

 Content-Type : text/plain; charset=ISO-8859-1

Transfer-Encoding : chunked

Server : Jetty(6.0.2)

file: { “resource” : { “name” : “test post”, “data” : “some data” } }






Table: Rest Fixture 		http://localhost:9876
setMultipartFileName target/live-docs-temp/tempfile
setMultipartFileParameterName abc123
POST /resources/

200

 Content-Type : text/plain; charset=ISO-8859-1

Transfer-Encoding : chunked

Server : Jetty(6.0.2)

abc123: { “resource” : { “name” : “test post”, “data” : “some data” } }


Use simple file upload





Table: Rest Fixture 		http://localhost:9876
setFileName target/live-docs-temp/tempfile
POST /resources/

200

 Content-Type : text/plain; charset=ISO-8859-1

Transfer-Encoding : chunked

Server : Jetty(6.0.2)

{ “resource” : { “name” : “test post”, “data” : “some data” } }






script
smartrics.rest.test.fitnesse.fixture.FileUtilFixture
name target/live-docs-temp/tempfile
check delete

true
check exists

false


Other than the aforementioned content types you can emulate form POSTs.

Remember to escape the setBody content cell with





Table: Rest Fixture 		http://localhost:9876
setHeader Content-Type : application/x-www-form-urlencoded;charset=UTF-8
setBody name=test%20post&data=some%20data
POST /resources

201

 Location : /resources/4

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 4






Table: Rest Fixture 		http://localhost:9876
GET /resources/4

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 68

Server : Jetty(6.0.2)



 /resource/name[text()=‘test post’]

 /resource/data[text()=‘some data’]



expected


<resource>

<name>test post</name>

<data>some data</data>

</resource>


actual


Header values can also be substituted with symbols previously defined:





Table: Rest Fixture 		http://localhost:9876
let contenttype const application/x-www-form-urlencoded;charset=UTF-8 application/x-www-form-urlencoded;charset=UTF-8
setHeader Content-Type : application/x-www-form-urlencoded;charset=UTF-8
setBody name=test%20post&data=some%20data
POST /resources

201

 Location : /resources/5

Content-Length : 0

Server : Jetty(6.0.2)

no-body
let id header Location:/resources/(.+) 5






Table: Rest Fixture 		http://localhost:9876
GET /resources/5

200

 Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 68

Server : Jetty(6.0.2)



 /resource/name[text()=‘test post’]

 /resource/data[text()=‘some data’]



expected


<resource>

<name>test post</name>

<data>some data</data>

</resource>


actual


PutTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database



 
Note
This test shows how to pass bespoke headers in the request. In this specific case, the stub echoes back the ‘Echo-Header’, so that the

following PUT and GET can match it the response.






Table: Rest Fixture 		http://localhost:9876
setBody

<resource><name>name being updated</name><data>data being updated</data></resource>


expected


<resource><name>name being updated</name><data>data being updated</data></resource>


actual
setHeader Echo-Header : echoed
PUT /resources/0

200

Echo-Header : echoed


expected


Echo-Header : echoed

Content-Length : 0

Server : Jetty(6.0.2)


actual

no-body
GET /resources/0

200

Echo-Header : echoed


expected


Echo-Header : echoed

Content-Type : application/xml;charset=ISO-8859-1

Content-Length : 83

Server : Jetty(6.0.2)


actual



 /resource/name[text()=‘name being updated’] <br/>

 /resource/data[text()=‘data being updated’]



expected


<resource><name>name being updated</name><data>data being updated</data></resource>


actual

TraceTests

 
Precompiled Libraries





 
Included page: .RestFixtureTests.SetUp (edit)





script
smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true

reset resources database


TRACE requests are supported too:





Table: Rest Fixture 		http://localhost:9876
TRACE /resources/0

200

Content-Type : message/http


expected


Content-Type : message/http

Content-Length : 130

Server : Jetty(6.0.2)


actual

 TRACE /resources/0 HTTP/1.1

anotherDefHeader: 2

defHeader: 1

User-Agent: Jakarta Commons-HttpClient/3.1

Host: localhost:9876

SuiteTearDown

 
Precompiled Libraries



script

smartrics.rest.test.fitnesse.fixture.HttpServerFixture
check is started

true
stop server
check is stopped

true
Add a custom footer
⚠️ **GitHub.com Fallback** ⚠️