218524989

Build Type

github

Committed by GitHub

Commit Message

Merge 6b0571679 into b02af5604

Pull Request Pull Request #51: Upgrade deps

Run Details

197 of 209 branches covered (94.26%)

Branch coverage included in aggregate %.

113 of 114 new or added lines in 14 files covered. (99.12%)

2 existing lines in 2 files now uncovered.

600 of 616 relevant lines covered (97.4%)

130.62 hits per line

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

90.0

/src/extensions/http_api/definitions.js

'use strict'

const { Given, Then, When } = require('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 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())))
    })

    Given(/^(?:I )?pick response json (.+) as (.+)$/, function (path, key) {
        const response = this.httpApiClient.getResponse()
        const body = response.body

        this.state.set(key, _.get(body, 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) (.+)$/, 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 spec = table.hashes().map((fieldSpec) =>
            _.assign({}, fieldSpec, {
                value: this.state.populate(fieldSpec.value),
            })
        )

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

ekino / veggies / 218524989

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