1698126267

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/ekino/veggies/commit/<a class=hub.com/ekino/veggies/commit/<a class="double-link" href="https://git"><a class=hub.com/ekino/veggies/commit/<a class="double-link" href="https://git"><a class=hub.com/ekino/veggies/commit/<a class="double-link" href="https://git"><a class=hub.com/ekino/veggies/commit/e2a853e781e16924c44aa0aff489086fa12e54d1">e2a853e78">&lt;a href=&quot;https://github.com/ekino/veggies/commit/</a><a class="double-link" href="https://github.com/ekino/veggies/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ekino/veggies/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ekino/veggies/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ekino/veggies/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ekino/veggies/commit/e2a853e781e16924c44aa0aff489086fa12e54d1">e2a853e78</a><a href="https://github.com/ekino/veggies/commit/e2a853e781e16924c44aa0aff489086fa12e54d1">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ekino/veggies/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ekino/veggies/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ekino/veggies/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ekino/veggies/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ekino/veggies/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ekino/veggies/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ekino/veggies/commit/e2a853e781e16924c44aa0aff489086fa12e54d1&quot;&gt;e2a853e78&lt;/a&gt;&lt;a href=&quot;https://github.com/ekino/veggies/commit/e2a853e781e16924c44aa0aff489086fa12e54d1&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/ekino/veggies/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot... (continued)

Pull Request Pull Request #78: feat(e2e): add end to end testing solution

Run Details

227 of 241 branches covered (94.19%)

Branch coverage included in aggregate %.

1 of 3 new or added lines in 1 file covered. (33.33%)

641 of 658 relevant lines covered (97.42%)

114.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.1

/src/extensions/http_api/definitions.js

'use strict'

const { Given, Then, When } = require('@cucumber/cucumber')
const { inspect } = require('util')
const { expect } = require('chai')
const _ = require('lodash')

const Cast = require('../../core/cast')
const { assertObjectMatchSpec } = require('../../core/assertions')

const { STATUS_CODES } = require('http')
const { parseMatchExpression } = require('./utils')
const STATUS_MESSAGES = _.values(STATUS_CODES).map(_.lowerCase)

/**
 * Ensures there's a response available and returns it.
 *
 * @param {Object} client
 */
const mustGetResponse = (client) => {
    const response = client.getResponse()
    expect(response, 'No response available').to.not.be.empty

    return response
}

exports.install = ({ baseUrl = '' } = {}) => {
    /**
     * Setting http headers
     */
    Given(/^(?:I )?set request headers$/, function (step) {
        this.httpApiClient.setHeaders(Cast.object(this.state.populateObject(step.rowsHash())))
    })

    /**
     * Setting http option followRedirect to false
     */
    Given(/^(?:I )?do not follow redirect$/, function () {
        this.httpApiClient.setFollowRedirect(false)
    })

    /**
     * Setting http option followRedirect to true
     */
    Given(/^(?:I )?follow redirect$/, function () {
        this.httpApiClient.setFollowRedirect(true)
    })

    /**
     * Assign http headers
     * The difference from "set request headers" is that "set" set the whole headers object
     * "assign" replace or set the given headers, keeping untouched the ones already set
     */
    Given(/^(?:I )?assign request headers$/, function (step) {
        const headers = Cast.object(this.state.populateObject(step.rowsHash()))
        _.each(headers, (value, key) => this.httpApiClient.setHeader(key, value))
    })

    /**
     * Setting a single http header
     */
    Given(/^(?:I )?set ([a-zA-Z0-9-_]+) request header to (.+)$/, function (key, value) {
        this.httpApiClient.setHeader(key, Cast.value(this.state.populate(value)))
    })

    /**
     * Clearing headers
     */
    Given(/^(?:I )?clear request headers/, function () {
        this.httpApiClient.clearHeaders()
    })

    /**
     * Setting json payload
     */
    Given(/^(?:I )?set request json body$/, function (step) {
        this.httpApiClient.setJsonBody(Cast.object(this.state.populateObject(step.rowsHash())))
    })

    /**
     * Setting json payload from fixture file
     */
    Given(/^(?:I )?set request json body from (.+)$/, function (fixture) {
        return this.fixtures.load(fixture).then((data) => {
            this.httpApiClient.setJsonBody(data)
        })
    })

    /**
     * Setting form data
     */
    Given(/^(?:I )?set request form body$/, function (step) {
        this.httpApiClient.setFormBody(Cast.object(this.state.populateObject(step.rowsHash())))
    })

    /**
     * Setting form data from fixture file
     */
    Given(/^(?:I )?set request form body from (.+)$/, function (fixture) {
        return this.fixtures.load(fixture).then((data) => {
            this.httpApiClient.setFormBody(data)
        })
    })

    /**
     * Setting multipart data from fixture file
     */
    Given(/^(?:I )?set request multipart body from (.+)$/, function (fixture) {
        return this.fixtures.load(fixture).then((data) => {
            this.httpApiClient.setMultipartBody(data)
        })
    })

    /**
     * Clearing body
     */
    Given(/^(?:I )?clear request body$/, function () {
        this.httpApiClient.clearBody()
    })

    /**
     * Setting query parameters
     */
    Given(/^(?:I )?set request query$/, function (step) {
        this.httpApiClient.setQuery(Cast.object(this.state.populateObject(step.rowsHash())))
    })

    /**
     * Pick a value from previous json response or header and set it to state
     */
    Given(/^(?:I )?pick response (json|header) (.+) as (.+)$/, function (dataSource, path, key) {
        const response = this.httpApiClient.getResponse()
        let data = dataSource !== 'header' ? response.body : response.headers

        this.state.set(key, _.get(data, path))
    })

    /**
     * Enabling cookies
     */
    Given(/^(?:I )?enable cookies$/, function () {
        this.httpApiClient.enableCookies()
    })

    /**
     * Disabling cookies
     */
    Given(/^(?:I )?disable cookies$/, function () {
        this.httpApiClient.disableCookies()
    })

    /**
     * Setting a cookie from fixture file
     */
    Given(/^(?:I )?set cookie from (.+)$/, function (fixture) {
        return this.fixtures.load(fixture).then((cookie) => {
            this.httpApiClient.setCookie(cookie)
        })
    })

    /**
     * Clearing client request cookies
     */
    Given(/^(?:I )?clear request cookies$/, function () {
        this.httpApiClient.clearRequestCookies()
    })

    /**
     * Resetting the client's state
     */
    When(/^(?:I )?reset http client$/, function () {
        this.httpApiClient.reset()
    })

    /**
     * Performing a request
     */
    When(/^(?:I )?(GET|POST|PUT|DELETE|PATCH) (.+)$/, function (method, path) {
        return this.httpApiClient.makeRequest(method, this.state.populate(path), baseUrl)
    })

    /**
     * Dumping response body
     */
    When(/^(?:I )?dump response body$/, function () {
        const response = mustGetResponse(this.httpApiClient)
        console.log(inspect(response.body, { colors: true, depth: null })) // eslint-disable-line no-console
    })

    /**
     * Dumping response headers
     */
    When(/^(?:I )?dump response headers$/, function () {
        const response = mustGetResponse(this.httpApiClient)
        console.log(response.headers) // eslint-disable-line no-console
    })

    /**
     * Dumping response cookies
     */
    When(/^(?:I )?dump response cookies$/, function () {
        mustGetResponse(this.httpApiClient)
        console.log(this.httpApiClient.getCookies()) // eslint-disable-line no-console
    })

    /**
     * Checking response status code
     */
    Then(/^response status code should be ([1-5][0-9][0-9])$/, function (statusCode) {
        const response = mustGetResponse(this.httpApiClient)
        expect(
            response.statusCode,
            `Expected status code to be: ${statusCode}, but found: ${response.statusCode}`
        ).to.equal(Number(statusCode))
    })

    /**
     * Checking response status by message
     */
    Then(/^response status should be (.+)$/, function (statusMessage) {
        if (!STATUS_MESSAGES.includes(_.lowerCase(statusMessage))) {
            throw new TypeError(`'${statusMessage}' is not a valid status message`)
        }

        const response = mustGetResponse(this.httpApiClient)
        const statusCode = _.findKey(STATUS_CODES, (msg) => _.lowerCase(msg) === statusMessage)
        const currentStatusMessage = STATUS_CODES[`${response.statusCode}`] || response.statusCode

        expect(
            response.statusCode,
            `Expected status to be: '${statusMessage}', but found: '${_.lowerCase(
                currentStatusMessage
            )}'`
        ).to.equal(Number(statusCode))
    })

    /**
     * Checking response cookie is present|absent
     */
    Then(/^response should (not )?have an? (.+) cookie$/, function (flag, key) {
        const cookie = this.httpApiClient.getCookie(key)

        if (flag == undefined) {
            expect(cookie, `No cookie found for key '${key}'`).to.not.be.null
        } else {
            expect(cookie, `A cookie exists for key '${key}'`).to.be.null
        }
    })

    /**
     * Checking response cookie is|isn't secure
     */
    Then(/^response (.+) cookie should (not )?be secure$/, function (key, flag) {
        const cookie = this.httpApiClient.getCookie(key)
        expect(cookie, `No cookie found for key '${key}'`).to.not.be.null

        if (flag == undefined) {
            expect(cookie.secure, `Cookie '${key}' is not secure`).to.be.true
        } else {
            expect(cookie.secure, `Cookie '${key}' is secure`).to.be.false
        }
    })

    /**
     * Checking response cookie httpOnly
     */
    Then(/^response (.+) cookie should (not )?be http only$/, function (key, flag) {
        const cookie = this.httpApiClient.getCookie(key)
        expect(cookie, `No cookie found for key '${key}'`).to.not.be.null

        if (flag == undefined) {
            expect(cookie.httpOnly, `Cookie '${key}' is not http only`).to.be.true
        } else {
            expect(cookie.httpOnly, `Cookie '${key}' is http only`).to.be.false
        }
    })

    /**
     * Checking response cookie domain
     */
    Then(/^response (.+) cookie domain should (not )?be (.+)$/, function (key, flag, domain) {
        const cookie = this.httpApiClient.getCookie(key)
        expect(cookie, `No cookie found for key '${key}'`).to.not.be.null

        if (flag == undefined) {
            expect(
                cookie.domain,
                `Expected cookie '${key}' domain to be '${domain}', found '${cookie.domain}'`
            ).to.equal(domain)
        } else {
            expect(cookie.domain, `Cookie '${key}' domain is '${domain}'`).to.not.equal(domain)
        }
    })

    /**
     * This definition can be used for checking an object response.
     * It check that the properties of this object match with the expected properties
     * The columns header are | field | matcher | value |
     * @see Assertions.assertObjectMatchSpec
     */
    Then(/^(?:I )?json response should (fully )?match$/, function (fully, table) {
        const response = mustGetResponse(this.httpApiClient)
        const { body } = response

        // We check the response has json content-type
        expect(response.headers['content-type']).to.contain('application/json')

        // First we populate spec values if it contains some placeholder
        const specifications = table.hashes().map((fieldSpec) => {
            const spec = fieldSpec.expression
                ? parseMatchExpression(fieldSpec.expression)
                : fieldSpec
            return _.assign({}, spec, {
                value: this.state.populate(spec.value),
            })
        })

        assertObjectMatchSpec(body, specifications, !!fully)
    })

    /**
     * This definition verify that an array for a given path has the expected length
     */
    Then(
        /^(?:I )?should receive a collection of ([0-9]+) items?(?: for path )?(.+)?$/,
        function (size, path) {
            const response = mustGetResponse(this.httpApiClient)
            const { body } = response

            const array = path != undefined ? _.get(body, path) : body

            expect(array.length).to.be.equal(Number(size))
        }
    )

    /**
     * Verifies that response matches a fixture.
     **/
    Then(/^response should match fixture (.+)$/, function (fixtureId) {
        const response = mustGetResponse(this.httpApiClient)

        return this.fixtures.load(fixtureId).then((snapshot) => {
            expect(response.body).to.deep.equal(snapshot)
        })
    })

    /**
     * Checking response header.
     */
    Then(
        /^response header (.+) should (not )?(equal|contain|match) (.+)$/,
        function (key, flag, comparator, expectedValue) {
            const response = mustGetResponse(this.httpApiClient)
            const header = response.headers[key.toLowerCase()]

            expect(header, `Header '${key}' does not exist`).to.not.be.undefined

            let expectFn = expect(
                header,
                `Expected header '${key}' to ${
                    flag ? flag : ''
                }${comparator} '${expectedValue}', but found '${header}' which does${
                    flag ? '' : ' not'
                }`
            ).to
            if (flag != undefined) {
                expectFn = expectFn.not
            }
            expectFn[comparator](comparator === 'match' ? new RegExp(expectedValue) : expectedValue)
        }
    )
}

1	'use strict'
2
3	const { Given, Then, When } = require('@cucumber/cucumber')	6✔
4	const { inspect } = require('util')	6✔
5	const { expect } = require('chai')	6✔
6	const _ = require('lodash')	6✔
7
8	const Cast = require('../../core/cast')	6✔
9	const { assertObjectMatchSpec } = require('../../core/assertions')	6✔
10
11	const { STATUS_CODES } = require('http')	6✔
12	const { parseMatchExpression } = require('./utils')	6✔
13	const STATUS_MESSAGES = _.values(STATUS_CODES).map(_.lowerCase)	6✔
14
15	/**
16	* Ensures there's a response available and returns it.
17	*
18	* @param {Object} client
19	*/
20	const mustGetResponse = (client) => {	6✔
21	const response = client.getResponse()	282✔
22	expect(response, 'No response available').to.not.be.empty	282✔
23
24	return response	282✔
25	}
26
27	exports.install = ({ baseUrl = '' } = {}) => {	6✔
28	/**
29	* Setting http headers
30	*/
31	Given(/^(?:I )?set request headers$/, function (step) {	294✔
32	this.httpApiClient.setHeaders(Cast.object(this.state.populateObject(step.rowsHash())))	6✔
33	})
34
35	/**
36	* Setting http option followRedirect to false
37	*/
38	Given(/^(?:I )?do not follow redirect$/, function () {	294✔
39	this.httpApiClient.setFollowRedirect(false)	6✔
40	})
41
42	/**
43	* Setting http option followRedirect to true
44	*/
45	Given(/^(?:I )?follow redirect$/, function () {	294✔
46	this.httpApiClient.setFollowRedirect(true)	6✔
47	})
48
49	/**
50	* Assign http headers
51	* The difference from "set request headers" is that "set" set the whole headers object
52	* "assign" replace or set the given headers, keeping untouched the ones already set
53	*/
54	Given(/^(?:I )?assign request headers$/, function (step) {	294✔
55	const headers = Cast.object(this.state.populateObject(step.rowsHash()))	6✔
56	_.each(headers, (value, key) => this.httpApiClient.setHeader(key, value))	12✔
57	})
58
59	/**
60	* Setting a single http header
61	*/
62	Given(/^(?:I )?set ([a-zA-Z0-9-_]+) request header to (.+)$/, function (key, value) {	294✔
63	this.httpApiClient.setHeader(key, Cast.value(this.state.populate(value)))	18✔
64	})
65
66	/**
67	* Clearing headers
68	*/
69	Given(/^(?:I )?clear request headers/, function () {	294✔
70	this.httpApiClient.clearHeaders()	6✔
71	})
72
73	/**
74	* Setting json payload
75	*/
76	Given(/^(?:I )?set request json body$/, function (step) {	294✔
77	this.httpApiClient.setJsonBody(Cast.object(this.state.populateObject(step.rowsHash())))	×
78	})
79
80	/**
81	* Setting json payload from fixture file
82	*/
83	Given(/^(?:I )?set request json body from (.+)$/, function (fixture) {	294✔
84	return this.fixtures.load(fixture).then((data) => {	6✔
85	this.httpApiClient.setJsonBody(data)	6✔
86	})
87	})
88
89	/**
90	* Setting form data
91	*/
92	Given(/^(?:I )?set request form body$/, function (step) {	294✔
93	this.httpApiClient.setFormBody(Cast.object(this.state.populateObject(step.rowsHash())))	×
94	})
95
96	/**
97	* Setting form data from fixture file
98	*/
99	Given(/^(?:I )?set request form body from (.+)$/, function (fixture) {	294✔
100	return this.fixtures.load(fixture).then((data) => {	6✔
101	this.httpApiClient.setFormBody(data)	6✔
102	})
103	})
104
105	/**
106	* Setting multipart data from fixture file
107	*/
108	Given(/^(?:I )?set request multipart body from (.+)$/, function (fixture) {	294✔
109	return this.fixtures.load(fixture).then((data) => {	6✔
110	this.httpApiClient.setMultipartBody(data)	6✔
111	})
112	})
113
114	/**
115	* Clearing body
116	*/
117	Given(/^(?:I )?clear request body$/, function () {	294✔
118	this.httpApiClient.clearBody()	6✔
119	})
120
121	/**
122	* Setting query parameters
123	*/
124	Given(/^(?:I )?set request query$/, function (step) {	294✔
125	this.httpApiClient.setQuery(Cast.object(this.state.populateObject(step.rowsHash())))	6✔
126	})
127
128	/**
129	* Pick a value from previous json response or header and set it to state
130	*/
131	Given(/^(?:I )?pick response (json\|header) (.+) as (.+)$/, function (dataSource, path, key) {	294✔
132	const response = this.httpApiClient.getResponse()	×
NEW 133	let data = dataSource !== 'header' ? response.body : response.headers	×
134
NEW 135	this.state.set(key, _.get(data, path))	×
136	})
137
138	/**
139	* Enabling cookies
140	*/
141	Given(/^(?:I )?enable cookies$/, function () {	294✔
142	this.httpApiClient.enableCookies()	6✔
143	})
144
145	/**
146	* Disabling cookies
147	*/
148	Given(/^(?:I )?disable cookies$/, function () {	294✔
149	this.httpApiClient.disableCookies()	6✔
150	})
151
152	/**
153	* Setting a cookie from fixture file
154	*/
155	Given(/^(?:I )?set cookie from (.+)$/, function (fixture) {	294✔
156	return this.fixtures.load(fixture).then((cookie) => {	×
157	this.httpApiClient.setCookie(cookie)	×
158	})
159	})
160
161	/**
162	* Clearing client request cookies
163	*/
164	Given(/^(?:I )?clear request cookies$/, function () {	294✔
165	this.httpApiClient.clearRequestCookies()	×
166	})
167
168	/**
169	* Resetting the client's state
170	*/
171	When(/^(?:I )?reset http client$/, function () {	294✔
172	this.httpApiClient.reset()	6✔
173	})
174
175	/**
176	* Performing a request
177	*/
178	When(/^(?:I )?(GET\|POST\|PUT\|DELETE\|PATCH) (.+)$/, function (method, path) {	294✔
179	return this.httpApiClient.makeRequest(method, this.state.populate(path), baseUrl)	×
180	})
181
182	/**
183	* Dumping response body
184	*/
185	When(/^(?:I )?dump response body$/, function () {	294✔
186	const response = mustGetResponse(this.httpApiClient)	6✔
187	console.log(inspect(response.body, { colors: true, depth: null })) // eslint-disable-line no-console	6✔
188	})
189
190	/**
191	* Dumping response headers
192	*/
193	When(/^(?:I )?dump response headers$/, function () {	294✔
194	const response = mustGetResponse(this.httpApiClient)	×
195	console.log(response.headers) // eslint-disable-line no-console	×
196	})
197
198	/**
199	* Dumping response cookies
200	*/
201	When(/^(?:I )?dump response cookies$/, function () {	294✔
202	mustGetResponse(this.httpApiClient)	×
203	console.log(this.httpApiClient.getCookies()) // eslint-disable-line no-console	×
204	})
205
206	/**
207	* Checking response status code
208	*/
209	Then(/^response status code should be ([1-5][0-9][0-9])$/, function (statusCode) {	294✔
210	const response = mustGetResponse(this.httpApiClient)	12✔
211	expect(	12✔
212	response.statusCode,
213	`Expected status code to be: ${statusCode}, but found: ${response.statusCode}`
214	).to.equal(Number(statusCode))
215	})
216
217	/**
218	* Checking response status by message
219	*/
220	Then(/^response status should be (.+)$/, function (statusMessage) {	294✔
221	if (!STATUS_MESSAGES.includes(_.lowerCase(statusMessage))) {	18✔
222	throw new TypeError(`'${statusMessage}' is not a valid status message`)	6✔
223	}
224
225	const response = mustGetResponse(this.httpApiClient)	12✔
226	const statusCode = _.findKey(STATUS_CODES, (msg) => _.lowerCase(msg) === statusMessage)	60✔
227	const currentStatusMessage = STATUS_CODES[`${response.statusCode}`] \|\| response.statusCode	12!
228
229	expect(	12✔
230	response.statusCode,
231	`Expected status to be: '${statusMessage}', but found: '${_.lowerCase(
232	currentStatusMessage
233	)}'`
234	).to.equal(Number(statusCode))
235	})
236
237	/**
238	* Checking response cookie is present\|absent
239	*/
240	Then(/^response should (not )?have an? (.+) cookie$/, function (flag, key) {	294✔
241	const cookie = this.httpApiClient.getCookie(key)	24✔
242
243	if (flag == undefined) {	24✔
244	expect(cookie, `No cookie found for key '${key}'`).to.not.be.null	12✔
245	} else {
246	expect(cookie, `A cookie exists for key '${key}'`).to.be.null	12✔
247	}
248	})
249
250	/**
251	* Checking response cookie is\|isn't secure
252	*/
253	Then(/^response (.+) cookie should (not )?be secure$/, function (key, flag) {	294✔
254	const cookie = this.httpApiClient.getCookie(key)	24✔
255	expect(cookie, `No cookie found for key '${key}'`).to.not.be.null	24✔
256
257	if (flag == undefined) {	24✔
258	expect(cookie.secure, `Cookie '${key}' is not secure`).to.be.true	12✔
259	} else {
260	expect(cookie.secure, `Cookie '${key}' is secure`).to.be.false	12✔
261	}
262	})
263
264	/**
265	* Checking response cookie httpOnly
266	*/
267	Then(/^response (.+) cookie should (not )?be http only$/, function (key, flag) {	294✔
268	const cookie = this.httpApiClient.getCookie(key)	24✔
269	expect(cookie, `No cookie found for key '${key}'`).to.not.be.null	24✔
270
271	if (flag == undefined) {	24✔
272	expect(cookie.httpOnly, `Cookie '${key}' is not http only`).to.be.true	12✔
273	} else {
274	expect(cookie.httpOnly, `Cookie '${key}' is http only`).to.be.false	12✔
275	}
276	})
277
278	/**
279	* Checking response cookie domain
280	*/
281	Then(/^response (.+) cookie domain should (not )?be (.+)$/, function (key, flag, domain) {	294✔
282	const cookie = this.httpApiClient.getCookie(key)	24✔
283	expect(cookie, `No cookie found for key '${key}'`).to.not.be.null	24✔
284
285	if (flag == undefined) {	24✔
286	expect(	12✔
287	cookie.domain,
288	`Expected cookie '${key}' domain to be '${domain}', found '${cookie.domain}'`
289	).to.equal(domain)
290	} else {
291	expect(cookie.domain, `Cookie '${key}' domain is '${domain}'`).to.not.equal(domain)	12✔
292	}
293	})
294
295	/**
296	* This definition can be used for checking an object response.
297	* It check that the properties of this object match with the expected properties
298	* The columns header are \| field \| matcher \| value \|
299	* @see Assertions.assertObjectMatchSpec
300	*/
301	Then(/^(?:I )?json response should (fully )?match$/, function (fully, table) {	294✔
302	const response = mustGetResponse(this.httpApiClient)	120✔
303	const { body } = response	120✔
304
305	// We check the response has json content-type
306	expect(response.headers['content-type']).to.contain('application/json')	120✔
307
308	// First we populate spec values if it contains some placeholder
309	const specifications = table.hashes().map((fieldSpec) => {	120✔
310	const spec = fieldSpec.expression	360✔
311	? parseMatchExpression(fieldSpec.expression)
312	: fieldSpec
313	return _.assign({}, spec, {	360✔
314	value: this.state.populate(spec.value),
315	})
316	})
317
318	assertObjectMatchSpec(body, specifications, !!fully)	120✔
319	})
320
321	/**
322	* This definition verify that an array for a given path has the expected length
323	*/
324	Then(	294✔
325	/^(?:I )?should receive a collection of ([0-9]+) items?(?: for path )?(.+)?$/,
326	function (size, path) {
327	const response = mustGetResponse(this.httpApiClient)	12✔
328	const { body } = response	12✔
329
330	const array = path != undefined ? _.get(body, path) : body	12!
331
332	expect(array.length).to.be.equal(Number(size))	12✔
333	}
334	)
335
336	/**
337	* Verifies that response matches a fixture.
338	**/
339	Then(/^response should match fixture (.+)$/, function (fixtureId) {	294✔
340	const response = mustGetResponse(this.httpApiClient)	12✔
341
342	return this.fixtures.load(fixtureId).then((snapshot) => {	12✔
343	expect(response.body).to.deep.equal(snapshot)	12✔
344	})
345	})
346
347	/**
348	* Checking response header.
349	*/
350	Then(	294✔
351	/^response header (.+) should (not )?(equal\|contain\|match) (.+)$/,
352	function (key, flag, comparator, expectedValue) {
353	const response = mustGetResponse(this.httpApiClient)	108✔
354	const header = response.headers[key.toLowerCase()]	108✔
355
356	expect(header, `Header '${key}' does not exist`).to.not.be.undefined	108✔
357
358	let expectFn = expect(	72✔
359	header,
360	`Expected header '${key}' to ${
361	flag ? flag : ''	72✔
362	}${comparator} '${expectedValue}', but found '${header}' which does${
363	flag ? '' : ' not'	72✔
364	}`
365	).to
366	if (flag != undefined) {	72✔
367	expectFn = expectFn.not	36✔
368	}
369	expectFn[comparator](comparator === 'match' ? new RegExp(expectedValue) : expectedValue)	72✔
370	}
371	)
372	}

ekino / veggies / 1698126267

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous