4789

pending completion

Build # 4789

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #1082 from realityking/no-coffeescript

Remove automated compiling of CoffeeScript

Run Details

796 of 993 branches covered (80.16%)

11 of 11 new or added lines in 1 file covered. (100.0%)

1960 of 2116 relevant lines covered (92.63%)

527.35 hits per line

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

91.45

/lib/Dredd.js

const async = require('async');
const clone = require('clone');
const glob = require('glob');
const fs = require('fs');
const path = require('path');
const request = require('request');
const url = require('url');

const dreddTransactions = require('dredd-transactions');
const configureReporters = require('./configureReporters');
const handleRuntimeProblems = require('./handleRuntimeProblems');
const logger = require('./logger');
const Runner = require('./TransactionRunner');
const { applyConfiguration } = require('./configuration');

const options = require('./options.json');

const PROXY_ENV_VARIABLES = ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY'];
const FILE_DOWNLOAD_TIMEOUT = 5000;

function removeDuplicates(arr) {
  return arr.reduce((alreadyProcessed, currentItem) => {
    if (alreadyProcessed.indexOf(currentItem) === -1) {
      return alreadyProcessed.concat(currentItem);
    }
    return alreadyProcessed;
  }, []);
}

class Dredd {
  constructor(config) {
    this.init(config);
  }

  // This is here only because there there is no way how to spy a constructor in CoffeScript
  init(config) {
    this.configuration = applyConfiguration(config);
    this.configuration.http = {};
    this.tests = [];
    this.stats = {
      tests: 0,
      failures: 0,
      errors: 0,
      passes: 0,
      skipped: 0,
      start: 0,
      end: 0,
      duration: 0,
    };
    this.transactions = [];
    this.runner = new Runner(this.configuration);
    configureReporters(this.configuration, this.stats, this.tests, this.runner);
    this.logProxySettings();
  }

  logProxySettings() {
    const proxySettings = [];
    for (const envVariableName of Object.keys(process.env || {})) {
      const envVariableValue = process.env[envVariableName];
      if (!Array.from(PROXY_ENV_VARIABLES).includes(envVariableName.toUpperCase())) { continue; }
      if (envVariableValue === '') { continue; }
      proxySettings.push(`${envVariableName}=${envVariableValue}`);
    }

    if (proxySettings.length) {
      const message = `
HTTP(S) proxy specified by environment variables: \
${proxySettings.join(', ')}. Please read documentation on how
Dredd works with proxies:
https://dredd.org/en/latest/how-it-works/#using-https-proxy
`;
      logger.verbose(message);
    }
  }

  run(callback) {
    this.configDataIsEmpty = true;

    if (!this.configuration.files) { this.configuration.files = []; }
    if (!this.configuration.data) { this.configuration.data = {}; }

    const passedConfigData = {};

    const object = this.configuration.data || {};
    for (const key of Object.keys(object || {})) {
      const val = object[key];
      this.configDataIsEmpty = false;
      if (typeof val === 'string') {
        passedConfigData[key] = {
          filename: key,
          raw: val,
        };
      } else if (typeof val === 'object' && val.raw && val.filename) {
        passedConfigData[val.filename] = {
          filename: val.filename,
          raw: val.raw,
        };
      }
    }

    if (!this.configDataIsEmpty) {
      this.configuration.data = passedConfigData;
    }

    // Remove duplicate paths
    this.configuration.options.path = removeDuplicates(this.configuration.options.path);

    if (this.configuration.options.require) {
      let mod = this.configuration.options.require;
      const abs = fs.existsSync(mod) || fs.existsSync(`${mod}.js`);
      if (abs) {
        mod = path.resolve(mod);
      }
      try {
        // eslint-disable-next-line global-require, import/no-dynamic-require
        require(mod);
      } catch (err) {
        logger.error(`Error requiring module '${mod}':`, err.message);
        callback(err, this.stats);
        return;
      }
    }

    // Spin that merry-go-round
    logger.verbose('Expanding glob patterns.');
    this.expandGlobs((globsErr) => {
      if (globsErr) { return callback(globsErr, this.stats); }

      logger.verbose('Reading API description files.');
      this.loadFiles((loadErr) => {
        if (loadErr) { return callback(loadErr, this.stats); }

        logger.verbose('Parsing API description files and compiling a list of HTTP transactions to test.');
        this.compileTransactions((compileErr) => {
          if (compileErr) { return callback(compileErr, this.stats); }

          logger.verbose('Starting reporters and waiting until all of them are ready.');
          this.emitStart((emitStartErr) => {
            if (emitStartErr) { return callback(emitStartErr, this.stats); }

            logger.verbose('Starting transaction runner.');
            this.startRunner((runnerErr) => {
              if (runnerErr) { return callback(runnerErr, this.stats); }

              logger.verbose('Wrapping up testing.');
              this.transactionsComplete(callback);
            });
          });
        });
      });
    });
  }

  // Expand all globs
  expandGlobs(callback) {
    async.each(this.configuration.options.path, (globToExpand, globCallback) => {
      if (/^http(s)?:\/\//.test(globToExpand)) {
        this.configuration.files = this.configuration.files.concat(globToExpand);
        return globCallback();
      }

      glob(globToExpand, (err, match) => {
        if (err) { return globCallback(err); }
        this.configuration.files = this.configuration.files.concat(match);
        if (match.length === 0) {
          err = new Error(`
            API description document(s) not found on path:
            '${globToExpand}'
         `);
          return globCallback(err);
        }
        globCallback();
      });
    },
    (err) => {
      if (err) { return callback(err, this.stats); }

      if (this.configDataIsEmpty && this.configuration.files.length === 0) {
        err = new Error(`
API description document (or documents) not found on path:
'${this.configuration.options.path}'
`);
        return callback(err, this.stats);
      }

      // Remove duplicate filenames
      this.configuration.files = removeDuplicates(this.configuration.files);
      callback(null, this.stats);
    });
  }

  // Load all files
  loadFiles(callback) {
    // 6 parallel connections is a standard limit when connecting to one hostname,
    // use the same limit of parallel connections for reading/downloading files
    async.eachLimit(this.configuration.files, 6, (fileUrlOrPath, loadCallback) => {
      const { protocol, host } = url.parse(fileUrlOrPath);
      if (host && ['http:', 'https:'].includes(protocol)) {
        logger.verbose('Downloading remote file:', fileUrlOrPath);
        this.downloadFile(fileUrlOrPath, loadCallback);
      } else {
        this.readLocalFile(fileUrlOrPath, loadCallback);
      }
    },
    callback);
  }

  downloadFile(fileUrl, callback) {
    const opts = clone(this.configuration.http);
    opts.url = fileUrl;
    opts.timeout = FILE_DOWNLOAD_TIMEOUT;

    request.get(opts, (downloadError, res, body) => {
      let err;
      if (downloadError) {
        logger.debug(`Downloading ${fileUrl} errored:`, `${downloadError}` || downloadError.code);
        err = new Error(`
Error when loading file from URL '${fileUrl}'.
Is the provided URL correct?
`);
        return callback(err, this.stats);
      }
      if (!body || (res.statusCode < 200) || (res.statusCode >= 300)) {
        err = new Error(`
Unable to load file from URL '${fileUrl}'.
Server did not send any blueprint back and responded with status code ${res.statusCode}.
`);
        return callback(err, this.stats);
      }
      this.configuration.data[fileUrl] = { raw: body, filename: fileUrl };
      callback(null, this.stats);
    });
  }

  readLocalFile(filePath, callback) {
    fs.readFile(filePath, 'utf8', (readError, data) => {
      if (readError) {
        const err = new Error(`
Error when reading file '${filePath}' (${readError.message}).
Is the provided path correct?
`);
        return callback(err);
      }
      this.configuration.data[filePath] = { raw: data, filename: filePath };
      callback(null, this.stats);
    });
  }

  // Compile transactions from ASTs
  compileTransactions(callback) {
    this.transactions = [];

    // Compile HTTP transactions for each API description
    async.each(Object.keys(this.configuration.data), (filename, next) => {
      const fileData = this.configuration.data[filename];
      if (!fileData.annotations) { fileData.annotations = []; }

      logger.verbose('Compiling HTTP transactions from API description file:', filename);
      dreddTransactions.compile(fileData.raw, filename, (compilationError, compilationResult) => {
        if (compilationError) { return next(compilationError); }

        fileData.mediaType = compilationResult.mediaType;
        fileData.annotations = fileData.annotations.concat(compilationResult.annotations);
        this.transactions = this.transactions.concat(compilationResult.transactions);
        next();
      });
    },
    (runtimeError) => {
      if (!runtimeError) { runtimeError = handleRuntimeProblems(this.configuration.data); }
      callback(runtimeError, this.stats);
    });
  }

  // Start the runner
  emitStart(callback) {
    // More than one reporter is supported
    let reporterCount = this.configuration.emitter.listeners('start').length;

    // When event 'start' is emitted, function in callback is executed for each
    // reporter registered by listeners
    this.configuration.emitter.emit('start', this.configuration.data, (reporterError) => {
      if (reporterError) { logger.error(reporterError.message); }

      // Last called reporter callback function starts the runner
      reporterCount--;
      if (reporterCount === 0) {
        callback(null, this.stats);
      }
    });
  }

  startRunner(callback) {
    // Run all transactions
    this.runner.config(this.configuration);
    this.runner.run(this.transactions, callback);
  }

  transactionsComplete(callback) {
    let reporterCount = this.configuration.emitter.listeners('end').length;
    this.configuration.emitter.emit('end', () => {
      reporterCount--;
      if (reporterCount === 0) {
        callback(null, this.stats);
      }
    });
  }
}

module.exports = Dredd;
module.exports.options = options;

1	const async = require('async');	15✔
2	const clone = require('clone');	15✔
3	const glob = require('glob');	15✔
4	const fs = require('fs');	15✔
5	const path = require('path');	15✔
6	const request = require('request');	15✔
7	const url = require('url');	15✔
8
9	const dreddTransactions = require('dredd-transactions');	15✔
10	const configureReporters = require('./configureReporters');	15✔
11	const handleRuntimeProblems = require('./handleRuntimeProblems');	15✔
12	const logger = require('./logger');	15✔
13	const Runner = require('./TransactionRunner');	15✔
14	const { applyConfiguration } = require('./configuration');	15✔
15
16	const options = require('./options.json');	15✔
17
18	const PROXY_ENV_VARIABLES = ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY'];	15✔
19	const FILE_DOWNLOAD_TIMEOUT = 5000;	15✔
20
21	function removeDuplicates(arr) {	3✔
22	return arr.reduce((alreadyProcessed, currentItem) => {	1,371✔
23	if (alreadyProcessed.indexOf(currentItem) === -1) {	1,680✔
24	return alreadyProcessed.concat(currentItem);	1,512✔
25	}
26	return alreadyProcessed;	168✔
27	}, []);
28	}
29
30	class Dredd {
31	constructor(config) {
32	this.init(config);	699✔
33	}
34
35	// This is here only because there there is no way how to spy a constructor in CoffeScript
36	init(config) {
37	this.configuration = applyConfiguration(config);	699✔
38	this.configuration.http = {};	699✔
39	this.tests = [];	699✔
40	this.stats = {	699✔
41	tests: 0,
42	failures: 0,
43	errors: 0,
44	passes: 0,
45	skipped: 0,
46	start: 0,
47	end: 0,
48	duration: 0,
49	};
50	this.transactions = [];	699✔
51	this.runner = new Runner(this.configuration);	699✔
52	configureReporters(this.configuration, this.stats, this.tests, this.runner);	699✔
53	this.logProxySettings();	699✔
54	}
55
56	logProxySettings() {
57	const proxySettings = [];	699✔
58	for (const envVariableName of Object.keys(process.env \|\| {})) {	699!
59	const envVariableValue = process.env[envVariableName];	238,002✔
60	if (!Array.from(PROXY_ENV_VARIABLES).includes(envVariableName.toUpperCase())) { continue; }	238,002✔
61	if (envVariableValue === '') { continue; }	231!
62	proxySettings.push(`${envVariableName}=${envVariableValue}`);	231✔
63	}
64
65	if (proxySettings.length) {	699✔
66	const message = `	174✔
67	HTTP(S) proxy specified by environment variables: \
68	${proxySettings.join(', ')}. Please read documentation on how
69	Dredd works with proxies:
70	https://dredd.org/en/latest/how-it-works/#using-https-proxy
71	`;
72	logger.verbose(message);	174✔
73	}
74	}
75
76	run(callback) {
77	this.configDataIsEmpty = true;	696✔
78
79	if (!this.configuration.files) { this.configuration.files = []; }	696✔
80	if (!this.configuration.data) { this.configuration.data = {}; }	696✔
81
82	const passedConfigData = {};	696✔
83
84	const object = this.configuration.data \|\| {};	696!
85	for (const key of Object.keys(object \|\| {})) {	696!
86	const val = object[key];	147✔
87	this.configDataIsEmpty = false;	147✔
88	if (typeof val === 'string') {	147✔
89	passedConfigData[key] = {	12✔
90	filename: key,
91	raw: val,
92	};
93	} else if (typeof val === 'object' && val.raw && val.filename) {	135!
94	passedConfigData[val.filename] = {	135✔
95	filename: val.filename,
96	raw: val.raw,
97	};
98	}
99	}
100
101	if (!this.configDataIsEmpty) {	696✔
102	this.configuration.data = passedConfigData;	45✔
103	}
104
105	// Remove duplicate paths
106	this.configuration.options.path = removeDuplicates(this.configuration.options.path);	696✔
107
108	if (this.configuration.options.require) {	696✔
109	let mod = this.configuration.options.require;	9✔
110	const abs = fs.existsSync(mod) \|\| fs.existsSync(`${mod}.js`);	9✔
111	if (abs) {	9!
112	mod = path.resolve(mod);	×
113	}
114	try {	9✔
115	// eslint-disable-next-line global-require, import/no-dynamic-require
116	require(mod);	9✔
117	} catch (err) {
118	logger.error(`Error requiring module '${mod}':`, err.message);	3✔
119	callback(err, this.stats);	3✔
120	return;	3✔
121	}
122	}
123
124	// Spin that merry-go-round
125	logger.verbose('Expanding glob patterns.');	693✔
126	this.expandGlobs((globsErr) => {	693✔
127	if (globsErr) { return callback(globsErr, this.stats); }	687✔
128
129	logger.verbose('Reading API description files.');	675✔
130	this.loadFiles((loadErr) => {	675✔
131	if (loadErr) { return callback(loadErr, this.stats); }	675✔
132
133	logger.verbose('Parsing API description files and compiling a list of HTTP transactions to test.');	615✔
134	this.compileTransactions((compileErr) => {	615✔
135	if (compileErr) { return callback(compileErr, this.stats); }	615✔
136
137	logger.verbose('Starting reporters and waiting until all of them are ready.');	603✔
138	this.emitStart((emitStartErr) => {	603✔
139	if (emitStartErr) { return callback(emitStartErr, this.stats); }	603!
140
141	logger.verbose('Starting transaction runner.');	603✔
142	this.startRunner((runnerErr) => {	603✔
143	if (runnerErr) { return callback(runnerErr, this.stats); }	603!
144
145	logger.verbose('Wrapping up testing.');	603✔
146	this.transactionsComplete(callback);	603✔
147	});
148	});
149	});
150	});
151	});
152	}
153
154	// Expand all globs
155	expandGlobs(callback) {
156	async.each(this.configuration.options.path, (globToExpand, globCallback) => {	693✔
157	if (/^http(s)?:\/\//.test(globToExpand)) {	729✔
158	this.configuration.files = this.configuration.files.concat(globToExpand);	114✔
159	return globCallback();	114✔
160	}
161
162	glob(globToExpand, (err, match) => {	615✔
163	if (err) { return globCallback(err); }	609!
164	this.configuration.files = this.configuration.files.concat(match);	609✔
165	if (match.length === 0) {	609✔
166	err = new Error(`	12✔
167	API description document(s) not found on path:
168	'${globToExpand}'
169	`);
170	return globCallback(err);	12✔
171	}
172	globCallback();	597✔
173	});
174	},
175	(err) => {
176	if (err) { return callback(err, this.stats); }	687✔
177
178	if (this.configDataIsEmpty && this.configuration.files.length === 0) {	675!
179	err = new Error(`	×
180	API description document (or documents) not found on path:
181	'${this.configuration.options.path}'
182	`);
183	return callback(err, this.stats);	×
184	}
185
186	// Remove duplicate filenames
187	this.configuration.files = removeDuplicates(this.configuration.files);	675✔
188	callback(null, this.stats);	675✔
189	});
190	}
191
192	// Load all files
193	loadFiles(callback) {
194	// 6 parallel connections is a standard limit when connecting to one hostname,
195	// use the same limit of parallel connections for reading/downloading files
196	async.eachLimit(this.configuration.files, 6, (fileUrlOrPath, loadCallback) => {	675✔
197	const { protocol, host } = url.parse(fileUrlOrPath);	732✔
198	if (host && ['http:', 'https:'].includes(protocol)) {	732✔
199	logger.verbose('Downloading remote file:', fileUrlOrPath);	108✔
200	this.downloadFile(fileUrlOrPath, loadCallback);	108✔
201	} else {
202	this.readLocalFile(fileUrlOrPath, loadCallback);	624✔
203	}
204	},
205	callback);
206	}
207
208	downloadFile(fileUrl, callback) {
209	const opts = clone(this.configuration.http);	108✔
210	opts.url = fileUrl;	108✔
211	opts.timeout = FILE_DOWNLOAD_TIMEOUT;	108✔
212
213	request.get(opts, (downloadError, res, body) => {	108✔
214	let err;	108✔
215	if (downloadError) {	108✔
216	logger.debug(`Downloading ${fileUrl} errored:`, `${downloadError}` \|\| downloadError.code);	30!
217	err = new Error(`	30✔
218	Error when loading file from URL '${fileUrl}'.
219	Is the provided URL correct?
220	`);
221	return callback(err, this.stats);	30✔
222	}
223	if (!body \|\| (res.statusCode < 200) \|\| (res.statusCode >= 300)) {	78✔
224	err = new Error(`	30✔
225	Unable to load file from URL '${fileUrl}'.
226	Server did not send any blueprint back and responded with status code ${res.statusCode}.
227	`);
228	return callback(err, this.stats);	30✔
229	}
230	this.configuration.data[fileUrl] = { raw: body, filename: fileUrl };	48✔
231	callback(null, this.stats);	48✔
232	});
233	}
234
235	readLocalFile(filePath, callback) {
236	fs.readFile(filePath, 'utf8', (readError, data) => {	624✔
237	if (readError) {	624!
238	const err = new Error(`	×
239	Error when reading file '${filePath}' (${readError.message}).
240	Is the provided path correct?
241	`);
242	return callback(err);	×
243	}
244	this.configuration.data[filePath] = { raw: data, filename: filePath };	624✔
245	callback(null, this.stats);	624✔
246	});
247	}
248
249	// Compile transactions from ASTs
250	compileTransactions(callback) {
251	this.transactions = [];	615✔
252
253	// Compile HTTP transactions for each API description
254	async.each(Object.keys(this.configuration.data), (filename, next) => {	615✔
255	const fileData = this.configuration.data[filename];	690✔
256	if (!fileData.annotations) { fileData.annotations = []; }	690!
257
258	logger.verbose('Compiling HTTP transactions from API description file:', filename);	690✔
259	dreddTransactions.compile(fileData.raw, filename, (compilationError, compilationResult) => {	690✔
260	if (compilationError) { return next(compilationError); }	690!
261
262	fileData.mediaType = compilationResult.mediaType;	690✔
263	fileData.annotations = fileData.annotations.concat(compilationResult.annotations);	690✔
264	this.transactions = this.transactions.concat(compilationResult.transactions);	690✔
265	next();	690✔
266	});
267	},
268	(runtimeError) => {
269	if (!runtimeError) { runtimeError = handleRuntimeProblems(this.configuration.data); }	615!
270	callback(runtimeError, this.stats);	615✔
271	});
272	}
273
274	// Start the runner
275	emitStart(callback) {
276	// More than one reporter is supported
277	let reporterCount = this.configuration.emitter.listeners('start').length;	612✔
278
279	// When event 'start' is emitted, function in callback is executed for each
280	// reporter registered by listeners
281	this.configuration.emitter.emit('start', this.configuration.data, (reporterError) => {	612✔
282	if (reporterError) { logger.error(reporterError.message); }	1,350✔
283
284	// Last called reporter callback function starts the runner
285	reporterCount--;	1,350✔
286	if (reporterCount === 0) {	1,350✔
287	callback(null, this.stats);	612✔
288	}
289	});
290	}
291
292	startRunner(callback) {
293	// Run all transactions
294	this.runner.config(this.configuration);	603✔
295	this.runner.run(this.transactions, callback);	603✔
296	}
297
298	transactionsComplete(callback) {
299	let reporterCount = this.configuration.emitter.listeners('end').length;	603✔
300	this.configuration.emitter.emit('end', () => {	603✔
301	reporterCount--;	1,326✔
302	if (reporterCount === 0) {	1,326✔
303	callback(null, this.stats);	603✔
304	}
305	});
306	}
307	}
308
309	module.exports = Dredd;	15✔
310	module.exports.options = options;	15✔

apiaryio / dredd / 4789

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