frisby.node.txt

                                  ┏━━━━━━━━━━━━┓
                                  ┃   FRISBY   ┃
                                  ┗━━━━━━━━━━━━┛

ALTERNATIVES ==>                  #  - frisby (prefer)
                                  #     - uses node-fetch
                                  #  - supertest:
                                  #     - not maintained
                                  #     - uses superagent
                                  #  - chai-http:
                                  #     - uses superagent
                                  #     - Chai-specific
                                  #     - a little more features:
                                  #        - can assert REQ (not just RES) (not very useful)
                                  #        - helper functions to assert redirect status codes, Content-Type [S] and Cookie [S]

VERSION ==>                       #2.1.2
                                  #Assertions on HTTP response (status, headers, body)

                                  ┌──────────┐
                                  │   BASE   │
                                  └──────────┘

FREQ.*()->FREQ                    #All FREQ methods return FREQ
                                  #Also if FRISBY|FREQ.*(), FRISBY method returns FREQ

FRISBY|FREQ.use(FUNC(FREQ))       #Plugin system.
                                  #Just fires FUNC(FREQ)

                                  ┌─────────────┐
                                  │   REQUEST   │
                                  └─────────────┘

FRISBY|FREQ.fetch('URL'[, OBJ])   #Like fetch(...)
                                  #OBJ (beside regular fetch options):
                                  #  - urlEncode true: apply encodeURI() on 'URL'
FRISBY|FREQ.                      #Same as *.fetch() but:
 get|patch|post|put|del[ete](...) #  - with OBJ.method
                                  #  - apply JSON.stringify() on OBJ.body OBJ2
FRISBY|FREQ.fromJSON(VAL)         #Same as *.fetch() but using a fake request:
                                  #  - url '/'
                                  #  - status 200
                                  #  - headers Content-Type: application/json [S]
                                  #  - body VAL
FRISBY|FREQ.options(OBJ)          #Same as *.fetch() but with options OBJ

FRISBY.globalSetup(OPTS)          #OPTS.request are default fetch options
FRISBY|FREQ.setup(OPTS[, BOOL])   #Default are:
                                  #  - credentials 'include'
                                  #  - headers Content-Type: application/json [C], User-Agent: frisby/VERSION
                                  #  - timeout 5000
                                  #If BOOL true, replace instead of deep merge.

FRISBY.baseUrl('URL')             #For relative URLs
                                  #Can also use OPTS.request.baseUrl 'URL'
FRISBY.getBaseUrl()->'URL'        #

FRISBY|FREQ.timeout(NUM)          #
FREQ.timeout()->NUM               #

                                  ┌──────────────┐
                                  │   RESPONSE   │
                                  └──────────────┘

FREQ.promise()->PROMISE           #fetch()'s PROMISE
FREQ.then|catch(...)              #Same as FREQ.promise().then|catch(...)
                                  #Except default error handler: console.log() the JSON response
                                  #(unless OPTS.request.inspectOnFailure false)
FREQ.done(FUNC)                   #Same as FREQ.then(() => FUNC())

                                  ┌───────────────┐
                                  │   DEBUGGING   │
                                  └───────────────┘

FREQ.inspectRequest()             #console.log() request
FREQ.inspectRequestHeaders()      #console.log() request headers

FREQ.inspectResponse()            #console.log() response
FREQ.inspectStatus()              #console.log() response status
FREQ.inspectHeaders()             #console.log() response headers
FREQ.inspectBody()                #console.log() response body
FREQ.inspectJSON()                #console.log() response body, as JSON

                                  ┌────────────────┐
                                  │   ASSERTIONS   │
                                  └────────────────┘

FREQ.expect(...)                  #Throw ERROR if expectation on fetch()'s RES not met.
                                  #If fetch()'s PROMISE was rejected, expect[Not]() will not be checked,
                                  #i.e. PROMISE should be returned in the test's it()
FREQ.expectNot(...)               #Inverse

FREQ.expect(FUNC(RES))            #Asserts RES
FREQ.expect('status', NUM)        #Asserts RES.status
FREQ.expect
 ('header', 'VAR'[, VAL|REGEXP])  #Asserts RES.get('VAR'), case-insensitive.

FREQ.expect
 ('bodyContains', STR|REGEXP)     #Asserts stringified RES.body
FREQ.json(['VARR',] VAL)          #Asserts RES.body as a JSON value
                                  #If VAL is OBJ|ARR, check it is a subset
                                  #VAL can be REGEXP as well
                                  #Otherwise, check it is equal
                                  #VARR is path within body. It can contain:
                                  #  - & for "all OBJ keys"
                                  #  - * for "all OBJ|ARR indices"
                                  #  - ? for "at least one OBJ|ARR key"
FREQ.jsonStrict(['VARR',] VAL)    #Same but does a deepEqual()
FREQ.jsonTypes[Strict]            #Same but using JOI.validate(RES.body, SCHEMA) (see its doc)
 (['VARR',] SCHEMA)               #Uses OPTS.allowUnknown true (unknown properties) unless "Strict"

FRISBY|FREQ.addExpectHandler
 ('NAME', FUNC(RES, ...))         #Add custom FREQ.expect('NAME', ...)
FRISBY|FREQ.removeExpectHandler
 ('NAME')                         #