particle-api-js 11.1.7 → 12.0.1

package/test/Agent.spec.js

@@ -1,488 +0,0 @@
-'use strict';
-const FormData = require('form-data');
-const { sinon, expect } = require('./test-setup');
-const Agent = require('../src/Agent.js');
-
-describe('Agent', () => {
-	beforeEach(() => {
-		sinon.restore();
-	});
-
-	describe('constructor', () => {
-		it('calls setBaseUrl', () => {
-			const baseUrl = 'https://foo.com';
-			sinon.stub(Agent.prototype, 'setBaseUrl');
-			const agent = new Agent(baseUrl);
-			expect(agent.setBaseUrl).to.have.property('callCount', 1);
-			expect(agent.setBaseUrl.firstCall.args).to.have.lengthOf(1);
-			expect(agent.setBaseUrl.firstCall.args[0]).to.eql(baseUrl);
-		});
-	});
-
-	describe('sanitize files', () => {
-		it('can call sanitize will falsy value', () => {
-			const agent = new Agent();
-			expect(agent._sanitizeFiles(undefined)).to.be.undefined;
-		});
-
-		it('sanitizes file names', () => {
-			const agent = new Agent();
-			const original = { one: 'content1', two: 'content2' };
-			const actual = agent._sanitizeFiles(original);
-			expect(actual).to.eql({
-				'file': {
-					'data': 'content1',
-					'path': 'one'
-				},
-				'file2': {
-					'data': 'content2',
-					'path': 'two'
-				}
-			});
-		});
-	});
-
-	describe('resource operations', () => {
-		let uri, method, auth, headers, query, data, context, agent;
-
-		beforeEach(() => {
-			uri = 'http://example.com/v1';
-			method = 'get';
-			auth = 'fake-token';
-			headers = { 'X-FOO': 'foo', 'X-BAR': 'bar' };
-			query = 'foo=1&bar=2';
-			data = { foo: true, bar: false };
-			context = { blah: {} };
-			agent = new Agent();
-			agent.request = sinon.stub();
-			agent.request.resolves('fake-response');
-		});
-
-		it('can GET a resource', () => {
-			return agent.get({ uri, auth, headers, query, context }).then(() => {
-				expect(agent.request).to.be.calledWith({ uri, method, auth, headers, query, context });
-			});
-		});
-
-		it('can HEAD a resource', () => {
-			method = 'head';
-			return agent.head({ uri, auth, headers, query, context }).then(() => {
-				expect(agent.request).to.be.calledWith({ uri, method, auth, headers, query, context });
-			});
-		});
-
-		it('can POST a resource', () => {
-			method = 'post';
-			return agent.post({ uri, auth, headers, data, context }).then(() => {
-				expect(agent.request).to.be.calledWith({ uri, method, auth, headers, data, context });
-			});
-		});
-
-		it('can PUT a resource', () => {
-			method = 'put';
-			return agent.put({ uri, auth, headers, data, context, query }).then(() => {
-				expect(agent.request).to.be.calledWith({ uri, method, auth, headers, data, context, query });
-			});
-		});
-
-		it('can DELETE a resource', () => {
-			method = 'delete';
-			return agent.delete({ uri, auth, headers, data, context }).then(() => {
-				expect(agent.request).to.be.calledWith({ uri, method, auth, headers, data, context });
-			});
-		});
-	});
-
-	describe('authorize', () => {
-		let agent;
-
-		beforeEach(() => {
-			agent = new Agent();
-		});
-
-		it('authorize no auth is unchanged', () => {
-			expect(agent._getAuthorizationHeader(undefined)).to.eql({});
-		});
-
-		it('authorize with bearer', () => {
-			const auth = '123';
-			const bearer = 'Bearer 123';
-			const headers = agent._getAuthorizationHeader(auth);
-			expect(headers).to.eql({ Authorization: bearer });
-		});
-	});
-
-	describe('request', () => {
-		let agent;
-
-		beforeEach(() => {
-			agent = new Agent();
-			agent._promiseResponse = sinon.stub();
-			agent._promiseResponse.resolves('fake-response');
-			agent._buildRequest = sinon.stub();
-			agent._sanitizeFiles = sinon.stub();
-		});
-
-		it('sanitizes files from a request', () => {
-			const sanitizedFiles = { a:'a' };
-			const files = {};
-			const form = {};
-			agent._sanitizeFiles.returns(sanitizedFiles);
-
-			return agent.request({ uri: 'abc', method: 'post', data: '123', query: 'all', form, files })
-				.then((res) => {
-					expect(res).to.be.equal('fake-response');
-					expect(agent._sanitizeFiles).calledOnce.calledWith(sinon.match.same(files));
-				});
-		});
-
-		it('uses default arguments for request', () => {
-			const args = ['abc', { args: '123' }];
-			agent._buildRequest.returns(args);
-			return agent.request({ uri: 'abc', method:'post' })
-				.then((res) => {
-					expect(res).to.be.equal('fake-response');
-					expect(agent._promiseResponse).calledOnce.calledWith(args);
-				});
-		});
-
-		it('builds and sends the request', () => {
-			const agent = new Agent();
-			const options = {
-				uri: 'http://example.com/v1',
-				method: 'get',
-				auth: 'fake-token',
-				headers: { 'X-FOO': 'foo', 'X-BAR': 'bar' },
-				query: 'foo=1&bar=2',
-				data: { foo: true, bar: false },
-				files: undefined,
-				form: undefined,
-				context
-			};
-			agent._buildRequest = sinon.stub();
-			agent._buildRequest.returns('fake-request');
-			agent._promiseResponse = sinon.stub();
-			agent._promiseResponse.resolves('fake-response');
-
-			return agent.request(options).then((res) => {
-				expect(res).to.be.equal('fake-response');
-				expect(agent._buildRequest).calledOnce;
-				expect(agent._buildRequest).calledWith(options);
-				expect(agent._promiseResponse).calledOnce;
-				expect(agent._promiseResponse).calledWith('fake-request');
-			});
-		});
-
-		it('builds a promise to call _promiseResponse', () => {
-			const agent = new Agent();
-			const req = sinon.stub();
-			const response = {
-				ok: true,
-				status: 200,
-				json: () => Promise.resolve('response')
-			};
-			req.resolves(response);
-			const promise = agent._promiseResponse([], false, req);
-			expect(promise).has.property('then');
-			return promise.then((resp) => {
-				expect(resp).to.be.eql({
-					body: 'response',
-					statusCode: 200
-				});
-			});
-		});
-
-		it('can handle error responses', () => {
-			const failResponseData = [
-				{
-					name: 'error text includes body error description',
-					response: {
-						status: 404,
-						statusText: 'file not found',
-						text: () => Promise.resolve('{"error_description": "file not found"}')
-					},
-					errorDescription: 'HTTP error 404 from 123.url - file not found'
-				},
-				{
-					name: 'error text with no body description',
-					response: {
-						status: 404,
-						text: () => Promise.resolve(''),
-					},
-					errorDescription: 'HTTP error 404 from 123.url'
-				},
-				{
-					name: 'error text with no status',
-					response: {},
-					errorDescription: 'Network error from 123.url'
-				}
-			];
-			const agent = new Agent();
-			const req = sinon.stub();
-			const requests = failResponseData.map((failData) => {
-				const response = Object.assign({
-					ok: false
-				}, failData.response);
-				req.resolves(response);
-				const promise = agent._promiseResponse(['123.url'] , false, req);
-				return promise.catch((resp) => {
-					expect(resp.statusCode).to.eql(failData.response.status);
-					expect(resp.errorDescription).to.eql(failData.errorDescription);
-					expect(resp.shortErrorDescription).to.eql(failData.response.statusText);
-				});
-			});
-			return Promise.all(requests);
-		});
-	});
-
-	describe('build request', () => {
-		let agent;
-
-		beforeEach(() => {
-			agent = new Agent('abc');
-		});
-
-		it('uses a baseURL if provided', () => {
-			const [uri] = agent._buildRequest({ uri: '/uri', method: 'get' });
-			expect(uri).to.equal('abc/uri');
-		});
-
-		it('uses the provided uri if no baseURL is provided', () => {
-			agent.setBaseUrl(undefined);
-			const [uri] = agent._buildRequest({ uri: 'uri', method: 'get' });
-			expect(uri).to.equal('uri');
-		});
-
-		it('generates context headers when one is provided', () => {
-			const context = { tool: { name: 'spanner' } };
-			const [, opts] = agent._buildRequest({ uri: '/uri', method: 'get', context });
-			expect(opts.headers).to.have.property('X-Particle-Tool', 'spanner');
-		});
-
-		it('generates auth headers when an auth token is provided', () => {
-			const auth = 'abcd-1235';
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', auth });
-			expect(opts.headers).to.have.property('Authorization', `Bearer ${auth}`);
-		});
-
-		it('adds new query params with the given query object', () => {
-			const query = { foo: 1, bar: 2 };
-			const [uri] = agent._buildRequest({ uri: '/uri', method: 'get', query });
-			expect(uri).to.equal('abc/uri?foo=1&bar=2');
-		});
-
-		it('adds query params without colliding with existing ones', () => {
-			const query = { foo: 1, bar: 2 };
-			const [uri] = agent._buildRequest({ uri: '/uri?test=true', method: 'get', query });
-			expect(uri).to.equal('abc/uri?test=true&foo=1&bar=2');
-		});
-
-		it('adds the provided data as a JSON request body', () => {
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', data: { a: 'abcd' } });
-			expect(opts.body).to.eql('{"a":"abcd"}');
-			expect(opts.headers).to.have.property('Content-Type', 'application/json');
-		});
-
-		it('keeps the body as provided if it is a FormData instance', () => {
-			const data = new FormData();
-			data.append('file', 'data or blob');
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'put', data });
-			expect(opts.body).to.eql(data);
-			expect(opts.headers).to.not.have.property('Content-Type');
-		});
-
-		it('should setup form send when form data is given', () => {
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', form: { a: 'abcd' } });
-			expect(opts.body).to.eql('a=abcd');
-		});
-
-		it('should attach files', () => {
-			const files = {
-				file: { data: makeFile('filedata'), path: 'filepath' },
-				file2: { data: makeFile('file2data'), path: 'file2path' }
-			};
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', files });
-			expect(opts.body.toString()).to.equal('[object FormData]');
-			expect(extractFilename(opts.body, 'file', 0)).to.eql('filepath');
-			expect(extractFilename(opts.body, 'file2', 3)).to.eql('file2path');
-			expect(opts.headers).to.not.have.property('Content-Type');
-		});
-
-		it('should attach files and form data', () => {
-			const files = {
-				file: { data: makeFile('filedata'), path: 'filepath' },
-				file2: { data: makeFile('file2data'), path: 'file2path' }
-			};
-			const form = { form1: 'value1', form2: 'value2' };
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', files, form });
-			expect(opts.body.toString()).to.equal('[object FormData]');
-			expect(extractFilename(opts.body, 'file', 0)).to.eql('filepath');
-			expect(extractFilename(opts.body, 'file2', 3)).to.eql('file2path');
-			expect(extractFormName(opts.body, 'form1', 6, true)).to.eql('value1');
-			expect(extractFormName(opts.body, 'form2', 9, true)).to.eql('value2');
-			expect(opts.headers).to.not.have.property('Content-Type');
-		});
-
-		it('should handle nested dirs', () => {
-			const files = {
-				file: { data: makeFile('filedata'), path: 'filepath.ino' },
-				file2: { data: makeFile('file2data'), path: 'dir/file2path.cpp' }
-			};
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', files });
-			expect(extractFilename(opts.body, 'file', 0)).to.eql('filepath.ino');
-			expect(extractFilename(opts.body, 'file2', 3)).to.eql('dir/file2path.cpp');
-		});
-
-		it('sets the user agent to particle-api-js', () => {
-			const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get' });
-			expect(opts.headers).to.have.property('User-Agent').that.match(/^particle-api-js/);
-		});
-
-		if (!inBrowser()){
-			it('should handle Windows nested dirs', () => {
-				const files = {
-					file: { data: makeFile('filedata'), path: 'dir\\windowsfilepath.cpp' }
-				};
-				const [, opts] = agent._buildRequest({ uri: 'uri', method: 'get', files });
-				expect(extractFilename(opts.body, 'file', 0)).to.eql('dir/windowsfilepath.cpp');
-			});
-		}
-
-		function inBrowser(){
-			return typeof window !== 'undefined';
-		}
-
-		function makeFile(data){
-			if (inBrowser()){
-				return new Blob([data]);
-			} else {
-				return data;
-			}
-		}
-
-		function extractFilename(formData, fieldName, fieldIndex){
-			if (inBrowser()){
-				return formData.get(fieldName).name;
-			} else {
-				return /filename="([^"]*)"/.exec(formData._streams[fieldIndex])[1];
-			}
-		}
-
-		function extractFormName(formData, fieldName, fieldIndex){
-			if (inBrowser()){
-				return formData.get(fieldName);
-			} else {
-				return formData._streams[fieldIndex + 1];
-			}
-		}
-	});
-
-	describe('context', () => {
-		let agent;
-
-		beforeEach(() => {
-			agent = new Agent();
-		});
-
-		describe('_nameAtVersion', () => {
-			it('returns empty string when no name given', () => {
-				expect(agent._nameAtVersion('', '1.2.3')).to.eql('');
-			});
-
-			it('returns just the name when no version given', () => {
-				expect(agent._nameAtVersion('fred')).to.eql('fred');
-			});
-
-			it('returns name@version when both are given', () => {
-				expect(agent._nameAtVersion('fred', '1.2.3')).to.eql('fred@1.2.3');
-			});
-		});
-
-		describe('_getContextHeaders', () => {
-			it('generates the tool context when defined', () => {
-				const context = { tool: { name: 'spanner' } };
-				const subject = agent._getContextHeaders(context);
-				expect(subject).to.have.property('X-Particle-Tool', 'spanner');
-			});
-
-			it('does not add the tool context header when not defined',() => {
-				const context = { tool: { name2: 'spanner' } };
-				const subject = agent._getContextHeaders(context);
-				expect(subject).to.not.have.property('X-Particle-Tool');
-			});
-
-			it('generates the project context header when defined',() => {
-				const context = { project: { name: 'blinky' } };
-				const subject = agent._getContextHeaders(context);
-				expect(subject).to.have.property('X-Particle-Project', 'blinky');
-			});
-
-			it('does not generate the project context header when not defined',() => {
-				const context = { project: { name2: 'blinky' } };
-				const subject = agent._getContextHeaders(context);
-				expect(subject).to.not.have.property('X-Particle-Project');
-			});
-		});
-
-		describe('_getToolContext', () => {
-			it('does not add a header when the tool name is not defined', () => {
-				const tool = { noname: 'cli' };
-				const subject = agent._getToolContext(tool);
-				expect(subject).to.eql({});
-			});
-
-			it('adds a header when the tool is defined', () => {
-				const tool = { name: 'cli' };
-				const subject = agent._getToolContext(tool);
-				expect(subject).to.eql({ 'X-Particle-Tool': 'cli' });
-			});
-
-			it('adds a header when the tool and components is defined', () => {
-				const tool = {
-					name: 'cli',
-					version: '1.2.3',
-					components: [
-						{ name: 'bar', version: 'a.b.c' },
-						{ name: 'foo', version: '0.0.1' }
-					]
-				};
-				const subject = agent._getToolContext(tool);
-				expect(subject).to.eql({ 'X-Particle-Tool': 'cli@1.2.3, bar@a.b.c, foo@0.0.1' });
-			});
-		});
-
-		describe('_addProjectContext', () => {
-			it('adds a header when the project is defined', () => {
-				const project = { name: 'blinky' };
-				const subject = agent._getProjectContext(project);
-				expect(subject).to.have.property('X-Particle-Project', 'blinky');
-			});
-
-			it('does not set the header when the project has no name', () => {
-				const project = { noname: 'blinky' };
-				const subject = agent._getProjectContext(project);
-				expect(subject).to.not.have.property('X-Particle-Project');
-			});
-		});
-
-		describe('_buildSemicolonSeparatedProperties', () => {
-			const obj = { name: 'fred', color: 'pink' };
-
-			it('returns empty string when no default property', () => {
-				expect(agent._buildSemicolonSeparatedProperties(obj)).to.be.eql('');
-			});
-
-			it('returns empty string when default property does not exist', () => {
-				expect(agent._buildSemicolonSeparatedProperties(obj, 'job')).to.be.eql('');
-			});
-
-			it('returns the default property only', () => {
-				expect(agent._buildSemicolonSeparatedProperties({ name:'fred' }, 'name')).eql('fred');
-			});
-
-			it('returns the default property plus additional properties', () => {
-				expect(agent._buildSemicolonSeparatedProperties(obj, 'name')).eql('fred; color=pink');
-			});
-		});
-	});
-});

package/test/Client.spec.js

@@ -1,216 +0,0 @@
-'use strict';
-const { expect, sinon } = require('./test-setup');
-const Client = require('../src/Client');
-const fixtures = require('./fixtures');
-const Library = require('../src/Library');
-
-let api;
-const token = 'tok';
-let client;
-
-
-describe('Client', () => {
-	beforeEach(() => {
-		api = {};
-		client = new Client({ api: api, auth: token });
-	});
-
-	describe('constructor', () => {
-		it('sets the auth token', () => {
-			expect(client.auth).to.equal(token);
-		});
-		it('sets the api', () => {
-			expect(client.api).to.equal(api);
-		});
-	});
-
-	describe('libraries', () => {
-		it('resolves to a list of Library objects', () => {
-			api.listLibraries = () => Promise.resolve({ body: fixtures.read('libraries.json') });
-			return client.libraries().then(libraries => {
-				expect(libraries.length).to.equal(1);
-				expect(libraries[0].name).to.equal('neopixel');
-			});
-		});
-	});
-
-	describe('library', () => {
-		it('resolves to a Library objects', () => {
-			api.getLibrary = () => Promise.resolve({ body: fixtures.read('library.json') });
-			return client.library('neopixel').then(library => {
-				expect(library.name).to.equal('neopixel');
-			});
-		});
-	});
-
-	describe('libraryVersions', () => {
-		it('resolves to a Library objects', () => {
-			api.getLibraryVersions = () => Promise.resolve({ body: fixtures.read('libraryVersions.json') });
-			return client.libraryVersions().then(libraries => {
-				expect(libraries.length).to.equal(9);
-				expect(libraries[0].name).to.equal('neopixel');
-				expect(libraries[0].version).to.equal('0.0.10');
-				expect(libraries[1].version).to.equal('0.0.9');
-			});
-		});
-	});
-
-	describe('downloadFile', () => {
-		it('delegates to api', () => {
-			api.downloadFile = ({ uri }) => Promise.resolve(`${uri} delegated`);
-			return expect(client.downloadFile('uri')).to.eventually.equal('uri delegated');
-		});
-	});
-
-	describe('compileCode', () => {
-		it('delegates to api', () => {
-			api.compileCode = ({ files, platformId, targetVersion, auth }) => {
-				return Promise.resolve([files, platformId, targetVersion, auth]);
-			};
-			return expect(client.compileCode('a', 'b', 'c')).to.eventually.eql(['a', 'b', 'c', client.auth]);
-		});
-	});
-
-	describe('signalDevice', () => {
-		it('delegates to api', () => {
-			api.signalDevice = () => {
-				return Promise.resolve([true, client.auth]);
-			};
-			return expect(client.signalDevice({ deviceId: 'testid', signal: true }))
-				.to.eventually.eql([true, client.auth]);
-		});
-	});
-
-	describe('publishLibrary', () => {
-		it('delegates to api and returns the library metadata on success', () => {
-			const name = 'fred';
-			const metadata = { name };
-			const library = new Library(client, metadata);
-			api.publishLibrary = sinon.stub().resolves({ body: { data: metadata } });
-			return client.publishLibrary(name)
-				.then(actual => {
-					expect(actual).to.eql(library);
-					expect(api.publishLibrary).to.have.been.calledWith({ name, auth:token });
-				});
-		});
-
-		it('delegates to api and calls _throwError to handle the error', () => {
-			const error = { message:'I don\'t like vegetables' };
-			api.publishLibrary = sinon.stub().rejects(error);
-			const name = 'notused';
-			return client.publishLibrary(name)
-				.then(() => {
-					throw new Error('expected an exception');
-				})
-				.catch(actual => {
-					expect(actual).to.eql(error);
-					expect(api.publishLibrary).to.have.been.calledWith({ name, auth:token });
-				});
-		});
-	});
-
-	describe('contributeLibrary', () => {
-		it('delegates to api and returns the library metadata on success', () => {
-			const archive = {};
-			const metadata = { name:'' };
-			const library = new Library(client, metadata);
-			api.contributeLibrary = sinon.stub().resolves({ body: { data: metadata } });
-			return client.contributeLibrary(archive)
-				.then(actual => {
-					expect(actual).to.eql(library);
-					expect(api.contributeLibrary).to.have.been.calledWith({ archive, auth:token });
-				});
-		});
-
-		it('delegates to api and calls _throwError to handle the error', () => {
-			const archive = {};
-			const error = { message:'I don\'t like vegetables' };
-			api.contributeLibrary = sinon.stub().rejects(error);
-			return client.contributeLibrary(archive)
-				.then(() => {
-					throw new Error('expected an exception');
-				})
-				.catch(actual => {
-					expect(actual).to.eql(error);
-					expect(api.contributeLibrary).to.have.been.calledWith({ archive, auth:token });
-				});
-		});
-	});
-
-	describe('listDevices', () => {
-		it('delegates to api', () => {
-			api.listDevices = ({ auth }) => {
-				return Promise.resolve([auth]);
-			};
-			return expect(client.listDevices()).to.eventually.eql([client.auth]);
-		});
-	});
-
-	describe('listBuildTargets', () => {
-		it('delegates to api', () => {
-			const response = {
-				targets: [
-					{
-						platforms: [0, 6],
-						prereleases: [],
-						version: '1.2.3',
-						firmware_vendor: 'Foo'
-					}, {
-						platforms: [6, 8],
-						prereleases: [6],
-						version: '4.5.6',
-						firmware_vendor: 'Bar'
-					}
-				]
-			};
-			const expected = [
-				{
-					version: '1.2.3',
-					platform: 0,
-					prerelease: false,
-					firmware_vendor: 'Foo'
-				}, {
-					version: '1.2.3',
-					platform: 6,
-					prerelease: false,
-
-					firmware_vendor: 'Foo'
-				}, {
-					version: '4.5.6',
-					platform: 6,
-					prerelease: true,
-					firmware_vendor: 'Bar'
-				}, {
-					version: '4.5.6',
-					platform: 8,
-					prerelease: false,
-					firmware_vendor: 'Bar'
-				},
-			];
-			api.listBuildTargets = () => {
-				return Promise.resolve({ body: response });
-			};
-			return expect(client.listBuildTargets()).to.eventually.eql(expected);
-		});
-	});
-
-	describe('trackingIdentity', () => {
-		it('delegates to api and unpacks the body', () => {
-			api.trackingIdentity = ({ auth, full, context }) => {
-				return Promise.resolve({ body: { auth, full, context } });
-			};
-			const context = { abd:123 };
-			const full = 456;
-			return expect(client.trackingIdentity({ full, context })).to.eventually.eql({ auth: client.auth, full, context });
-		});
-
-		it('delegates to api with default parameters and unpacks the body', () => {
-			api.trackingIdentity = ({ auth, full, context }) => {
-				return Promise.resolve({ body: { auth, full, context } });
-			};
-			const context = undefined;
-			const full = false;
-			return expect(client.trackingIdentity()).to.eventually.eql({ auth:client.auth, full, context });
-		});
-	});
-});