c26322d29c91cc8522ef0b79f4a06a0ab385b12f-PR-54

Build # c26322d29c91cc8522ef0b79f4a06a0ab385b12f-PR-54

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/nodebots/nodebots-interchange/commit/<a class=hub.com/nodebots/nodebots-interchange/commit/c26322d29c91cc8522ef0b79f4a06a0ab385b12f">c26322d29<a href="https://github.com/nodebots/nodebots-interchange/commit/c26322d29c91cc8522ef0b79f4a06a0ab385b12f">">Merge </a><a class="double-link" href="https://github.com/nodebots/nodebots-interchange/commit/<a class="double-link" href="https://github.com/nodebots/nodebots-interchange/commit/2fa2e25eba1cc2073ac491a7a7142eecab37099d">2fa2e25eb</a>">2fa2e25eb</a><a href="https://github.com/nodebots/nodebots-interchange/commit/c26322d29c91cc8522ef0b79f4a06a0ab385b12f"> into 6d585222b">6d585222b</a>

Pull Request Pull Request #54: Update of all modules with better tests

Run Details

139 of 159 branches covered (87.42%)

Branch coverage included in aggregate %.

280 of 280 new or added lines in 6 files covered. (100.0%)

341 of 349 relevant lines covered (97.71%)

5.17 hits per line

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

95.36

/lib/downloader.js

// This module executes the downloading of the files properly.
const axios         = require('axios');
const child_process = require('child_process');
const colors        = require('colors');
const fs            = require('fs');
const fsextra       = require('fs-extra');
const path          = require('path');
const tmp           = require('tmp');
const util          = require('util');

class Downloader {
  constructor(opts) {
    // set up the defaults

    this.fw = undefined;

    if (typeof(opts) === 'undefined') {
      this.fw = undefined;
    } else {
      this.fw = opts.fw || undefined;
    }
  }


  get_path_from_manifest(manifest, options) {
    // takes the manifest data and returns the path to the hex file

    // TODO - put in the bits here around installing from GH and having
    // multiple options.
    if (typeof(manifest) === 'undefined') {
      throw new Error('No manifest data provided');
    }

    if (typeof(options) === 'undefined') {
      throw new Error('No options provided');
    }

    let manifest_objects = (options.useFirmata ? manifest.firmata : manifest.backpack);
    // this deals with a firmata object supplied that isn't the default
    // one in order to grab the right hex file.
    if (options.useFirmata && options.firmataName != '') {
      manifest_objects = manifest.firmata[options.firmataName];
    } else if (options.useFirmata && options.firmataName == '' && manifest.firmata.multi != undefined) {
      // we have multiple firmatas and none have been supplied.
      throw new Error('Multiple firmatas are available, please supply a name');
    }

    if (manifest_objects.hexPath.indexOf('/') != 0) {
      manifest_objects.hexPath = '/' + manifest_objects.hexPath;
    }

    const hex_path = path.join(manifest_objects.bins, options.board, manifest_objects.hexPath);

    return (hex_path);
  }

  get_manifest_from_npm(firmware) {
    // gets the manifest file and returns the content

    if (typeof(firmware) === 'undefined') {
      throw new Error('No firmware details provided');
    }

    // as we have installed get the manifest file.
    const base_path = this.get_npm_basepath(firmware);
    const manifest_file = path.join(base_path, 'manifest.json');
    let manifest = null;

    try {
      manifest = JSON.parse(fs.readFileSync(manifest_file));
    } catch (e) {
      throw new Error('Manifest file incorrect');
    }

    return manifest;
  }

  get_npm_basepath(firmware) {
    // returns the base path of the folder when using npm installs
    if (typeof(firmware) === 'undefined') {
      throw new Error('No firmware details provided');
    }

    if (typeof(firmware.npm.package) === 'undefined') {
      throw new Error('No npm package provided');
    }

    return path.join('.', 'node_modules', firmware.npm.package);
  }

  async get_file_from_github(uri) {
    // gets the manifest file from github and returns it.
    return await axios.get(uri)
      .then((response) => {
        if (response.status == '200') {
          // got the data
          return response.data;
        }
      })
      .catch(err => {
        throw new Error('Unable to retrieve file')
      });
  }

  download_from_github(firmware, options) {
    // downloads the file from github and returns the path to the hex file
    // as well as the temp directory it exists in to clean it up
    let base_uri = null;
    return new Promise((resolve, reject) => { // need to try and reolve this async out
      // setup GH

      if (firmware === undefined) {
        reject(new Error('No firmware provided'));
      }

      /* istanbul ignore next */
      if (!process.env.TEST) {
        console.info(colors.magenta(`Installing ${firmware.name} from github`));
      }
      // work out where the manifest file is
      if (firmware.repo === undefined) {
        reject(new Error('No github repo specified'));
      }

      let manifest_uri = null;
      let branch = 'master';
      let repo = '';

      // console.log(firmware);
      if (firmware.repo.indexOf('git+https') == 0) {
        if (firmware.repo.indexOf('#') > 0 ) {
          // we want a branch so get that out of the URL
          branch = '/' + firmware.repo.substring(firmware.repo.indexOf('#') + 1);
          repo = firmware.repo.substring(22, firmware.repo.indexOf('#'));
        } else {
          repo = firmware.repo.substring(22);
          branch = '/master';
        }

        base_uri = `https://raw.githubusercontent.com${repo}${branch}`;
        manifest_uri = `${base_uri}/manifest.json?${(new Date().getTime())}`;
      } else {
        reject(new Error('Wrong protocol used for github'));
      }

      this.get_file_from_github(manifest_uri)
        .then((manifest) => resolve(manifest))
        .catch(err => reject(err));
    }).then((manifest) => {
      // now we process the manifest file, download the hex binary and then
      // save it and return a path to it.
      const bin_path = this.get_path_from_manifest(manifest, options);
      const bin_uri = `${base_uri}${bin_path}?${(new Date().getTime())}`;

      // save the hex file
      return this.get_file_from_github(bin_uri)
        .then(hexdata => {
          const tmpdir = tmp.dirSync();
          const hexpath = `${tmpdir.name}/bin.hex`;

          // turn the write file into a promise.
          const writeFile = util.promisify(fs.writeFile);

          // now write the file back.
          return writeFile(hexpath, hexdata)
            .then(() => {
              return {hexpath, tmpdir};
            })
            .catch(err => {
              fsextra.removeSync(tmpdir.name);
              tmpdir.removeCallback();
              throw err;
            });
        })
        .catch(err => {
          throw err;
        });
    });
  }

  download_from_npm(firmware, options) {
    // downloads the file from npm and returns the path to the hex file.
    return new Promise((resolve, reject) => {
      // Set up NPM.
      /* istanbul ignore next */
      if (!process.env.TEST) {
        console.info(colors.magenta('Installing ' + firmware.name + ' from npm'));
      }

      // first try to install the npm package
      let command = 'npm install --no-save ';

      // test to see if installing from a gh repo as an npm package.
      if (firmware.npm.repo !== undefined) {
        command = command + firmware.npm.repo;
      } else {
        if (typeof(firmware.npm.version) == 'undefined') {
          // just use "latest" from npm
          command = command + firmware.npm.package;
        } else {
          command = command + firmware.npm.package + '@' + firmware.npm.version;
        }
      }

      try {
        // simply call the command on the command line.
        child_process.execSync(command, {stdio: [0,1,2]});
      } catch (e) {
        reject(e);
      }

      const manifest = this.get_manifest_from_npm(firmware, options);

      let hexpath;
      try {
        hexpath = path.join(
          this.get_npm_basepath(firmware),
          this.get_path_from_manifest(manifest, options)
        );
      } catch (e) {
        reject(new Error('Cannot get path to hex file', e));
      }

      resolve({hexpath});
    });
  }

  download(firmware, options) {
    // manages the download of the firmware
    return new Promise((resolve, reject) => {
      // check and see if firmware is specified
      if (typeof(firmware) === 'undefined') {
        // set it to the constructor value
        firmware = this.fw;
      }

      // if we're still undefined then throw an error.
      if (typeof(firmware) === 'undefined') {
        const err = new Error('There is no firmware supplied');
        reject(err);
      }

      // now we choose what way to download the file
      // now check if the firmware is in npm or github.
      let downloader_to_use;
      if (firmware.npm == undefined) {
        // use git repo
        downloader_to_use = this.download_from_github.bind(this);
      } else {
        // get from npm now
        downloader_to_use = this.download_from_npm.bind(this);
      }

      downloader_to_use(firmware, options)
        .then((values) => {
          resolve(values);
        })
        .catch(err => reject(err));
    });
  }
}

module.exports = Downloader;

1	// This module executes the downloading of the files properly.
2	const axios = require('axios');	4✔
3	const child_process = require('child_process');	4✔
4	const colors = require('colors');	4✔
5	const fs = require('fs');	4✔
6	const fsextra = require('fs-extra');	4✔
7	const path = require('path');	4✔
8	const tmp = require('tmp');	4✔
9	const util = require('util');	4✔
10
11	class Downloader {
12	constructor(opts) {
13	// set up the defaults
14
15	this.fw = undefined;	29✔
16
17	if (typeof(opts) === 'undefined') {	29✔
18	this.fw = undefined;	26✔
19	} else {
20	this.fw = opts.fw \|\| undefined;	3!
21	}
22	}
23
24
25	get_path_from_manifest(manifest, options) {
26	// takes the manifest data and returns the path to the hex file
27
28	// TODO - put in the bits here around installing from GH and having
29	// multiple options.
30	if (typeof(manifest) === 'undefined') {	14✔
31	throw new Error('No manifest data provided');	1✔
32	}
33
34	if (typeof(options) === 'undefined') {	13✔
35	throw new Error('No options provided');	1✔
36	}
37
38	let manifest_objects = (options.useFirmata ? manifest.firmata : manifest.backpack);	12✔
39	// this deals with a firmata object supplied that isn't the default
40	// one in order to grab the right hex file.
41	if (options.useFirmata && options.firmataName != '') {	12✔
42	manifest_objects = manifest.firmata[options.firmataName];	1✔
43	} else if (options.useFirmata && options.firmataName == '' && manifest.firmata.multi != undefined) {	11✔
44	// we have multiple firmatas and none have been supplied.
45	throw new Error('Multiple firmatas are available, please supply a name');	1✔
46	}
47
48	if (manifest_objects.hexPath.indexOf('/') != 0) {	11✔
49	manifest_objects.hexPath = '/' + manifest_objects.hexPath;	1✔
50	}
51
52	const hex_path = path.join(manifest_objects.bins, options.board, manifest_objects.hexPath);	11✔
53
54	return (hex_path);	11✔
55	}
56
57	get_manifest_from_npm(firmware) {
58	// gets the manifest file and returns the content
59
60	if (typeof(firmware) === 'undefined') {	3✔
61	throw new Error('No firmware details provided');	1✔
62	}
63
64	// as we have installed get the manifest file.
65	const base_path = this.get_npm_basepath(firmware);	2✔
66	const manifest_file = path.join(base_path, 'manifest.json');	2✔
67	let manifest = null;	2✔
68
69	try {	2✔
70	manifest = JSON.parse(fs.readFileSync(manifest_file));	2✔
71	} catch (e) {
72	throw new Error('Manifest file incorrect');	1✔
73	}
74
75	return manifest;	1✔
76	}
77
78	get_npm_basepath(firmware) {
79	// returns the base path of the folder when using npm installs
80	if (typeof(firmware) === 'undefined') {	9✔
81	throw new Error('No firmware details provided');	1✔
82	}
83
84	if (typeof(firmware.npm.package) === 'undefined') {	8✔
85	throw new Error('No npm package provided');	1✔
86	}
87
88	return path.join('.', 'node_modules', firmware.npm.package);	7✔
89	}
90
91	async get_file_from_github(uri) {
92	// gets the manifest file from github and returns it.
93	return await axios.get(uri)	3✔
94	.then((response) => {
95	if (response.status == '200') {	1!
96	// got the data
97	return response.data;	1✔
98	}
99	})
100	.catch(err => {
101	throw new Error('Unable to retrieve file')	2✔
102	});
103	}
104
105	download_from_github(firmware, options) {
106	// downloads the file from github and returns the path to the hex file
107	// as well as the temp directory it exists in to clean it up
108	let base_uri = null;	6✔
109	return new Promise((resolve, reject) => { // need to try and reolve this async out	6✔
110	// setup GH
111
112	if (firmware === undefined) {	6✔
113	reject(new Error('No firmware provided'));	1✔
114	}
115
116	/* istanbul ignore next */
117	if (!process.env.TEST) {
118	console.info(colors.magenta(`Installing ${firmware.name} from github`));
119	}
120	// work out where the manifest file is
121	if (firmware.repo === undefined) {	6✔
122	reject(new Error('No github repo specified'));	1✔
123	}
124
125	let manifest_uri = null;	5✔
126	let branch = 'master';	5✔
127	let repo = '';	5✔
128
129	// console.log(firmware);
130	if (firmware.repo.indexOf('git+https') == 0) {	5✔
131	if (firmware.repo.indexOf('#') > 0 ) {	3✔
132	// we want a branch so get that out of the URL
133	branch = '/' + firmware.repo.substring(firmware.repo.indexOf('#') + 1);	1✔
134	repo = firmware.repo.substring(22, firmware.repo.indexOf('#'));	1✔
135	} else {
136	repo = firmware.repo.substring(22);	2✔
137	branch = '/master';	2✔
138	}
139
140	base_uri = `https://raw.githubusercontent.com${repo}${branch}`;	3✔
141	manifest_uri = `${base_uri}/manifest.json?${(new Date().getTime())}`;	3✔
142	} else {
143	reject(new Error('Wrong protocol used for github'));	1✔
144	}
145
146	this.get_file_from_github(manifest_uri)	4✔
147	.then((manifest) => resolve(manifest))	3✔
148	.catch(err => reject(err));	1✔
149	}).then((manifest) => {
150	// now we process the manifest file, download the hex binary and then
151	// save it and return a path to it.
152	const bin_path = this.get_path_from_manifest(manifest, options);	3✔
153	const bin_uri = `${base_uri}${bin_path}?${(new Date().getTime())}`;	3✔
154
155	// save the hex file
156	return this.get_file_from_github(bin_uri)	3✔
157	.then(hexdata => {
158	const tmpdir = tmp.dirSync();	2✔
159	const hexpath = `${tmpdir.name}/bin.hex`;	2✔
160
161	// turn the write file into a promise.
162	const writeFile = util.promisify(fs.writeFile);	2✔
163
164	// now write the file back.
165	return writeFile(hexpath, hexdata)	2✔
166	.then(() => {
167	return {hexpath, tmpdir};	2✔
168	})
169	.catch(err => {
170	fsextra.removeSync(tmpdir.name);	×
171	tmpdir.removeCallback();	×
172	throw err;	×
173	});
174	})
175	.catch(err => {
176	throw err;	1✔
177	});
178	});
179	}
180
181	download_from_npm(firmware, options) {
182	// downloads the file from npm and returns the path to the hex file.
183	return new Promise((resolve, reject) => {	4✔
184	// Set up NPM.
185	/* istanbul ignore next */
186	if (!process.env.TEST) {
187	console.info(colors.magenta('Installing ' + firmware.name + ' from npm'));
188	}
189
190	// first try to install the npm package
191	let command = 'npm install --no-save ';	4✔
192
193	// test to see if installing from a gh repo as an npm package.
194	if (firmware.npm.repo !== undefined) {	4✔
195	command = command + firmware.npm.repo;	1✔
196	} else {
197	if (typeof(firmware.npm.version) == 'undefined') {	3✔
198	// just use "latest" from npm
199	command = command + firmware.npm.package;	2✔
200	} else {
201	command = command + firmware.npm.package + '@' + firmware.npm.version;	1✔
202	}
203	}
204
205	try {	4✔
206	// simply call the command on the command line.
207	child_process.execSync(command, {stdio: [0,1,2]});	4✔
208	} catch (e) {
209	reject(e);	1✔
210	}
211
212	const manifest = this.get_manifest_from_npm(firmware, options);	4✔
213
214	let hexpath;
215	try {	4✔
216	hexpath = path.join(	4✔
217	this.get_npm_basepath(firmware),
218	this.get_path_from_manifest(manifest, options)
219	);
220	} catch (e) {
221	reject(new Error('Cannot get path to hex file', e));	×
222	}
223
224	resolve({hexpath});	4✔
225	});
226	}
227
228	download(firmware, options) {
229	// manages the download of the firmware
230	return new Promise((resolve, reject) => {	5✔
231	// check and see if firmware is specified
232	if (typeof(firmware) === 'undefined') {	5!
233	// set it to the constructor value
234	firmware = this.fw;	5✔
235	}
236
237	// if we're still undefined then throw an error.
238	if (typeof(firmware) === 'undefined') {	5✔
239	const err = new Error('There is no firmware supplied');	1✔
240	reject(err);	1✔
241	}
242
243	// now we choose what way to download the file
244	// now check if the firmware is in npm or github.
245	let downloader_to_use;
246	if (firmware.npm == undefined) {	5✔
247	// use git repo
248	downloader_to_use = this.download_from_github.bind(this);	2✔
249	} else {
250	// get from npm now
251	downloader_to_use = this.download_from_npm.bind(this);	2✔
252	}
253
254	downloader_to_use(firmware, options)	4✔
255	.then((values) => {
256	resolve(values);	2✔
257	})
258	.catch(err => reject(err));	2✔
259	});
260	}
261	}
262
263	module.exports = Downloader;	4✔

nodebots / nodebots-interchange / c26322d29c91cc8522ef0b79f4a06a0ab385b12f-PR-54

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