Box View API: Test framework tests

should be a truthy global

assert(framework, 'Expected global framework to be truthy, not: '+framework);

should be an object

assert(typeof framework === 'object', 'Expected framework to be an object, not: '+(typeof framework));

.assert

should be truthy

assert(framework.assert, 'Expected framework.assert to be truthy, not: '+framework.assert);

should be a function

assert(typeof framework.assert === 'function', 'Expected framework.assert to be a function, not: '+(typeof framework.assert));

.url

should be truthy

assert(framework.url, 'Expected framework.url to be truthy, not: '+framework.url);

should be an object

assert(typeof framework.url === 'object', 'Expected framework.url to be an object, not: '+(typeof framework.url));

.path

should be truthy

assert(framework.path, 'Expected framework.path to be truthy, not: '+framework.path);

should be an object

assert(typeof framework.path === 'object', 'Expected framework.path to be an object, not: '+(typeof framework.path));

.qs

should be truthy

assert(framework.qs, 'Expected framework.qs to be truthy, not: '+framework.qs);

should be an object

assert(typeof framework.qs === 'object', 'Expected framework.qs to be an object, not: '+(typeof framework.qs));

.inspect

should be truthy

assert(framework.inspect, 'Expected framework.inspect to be truthy, not: '+framework.inspect);

should be a function

assert(typeof framework.inspect === 'function', 'Expected framework.inspect to be a function, not: '+(typeof framework.inspect));

.exec

should be truthy

assert(framework.exec, 'Expected framework.exec to be truthy, not: '+framework.exec);

should be a function

assert(typeof framework.exec === 'function', 'Expected framework.exec to be a function, not: '+(typeof framework.exec));

.throwsError

should be truthy

assert(framework.throwsError, 'Expected framework.throwsError to be truthy, not: '+framework.throwsError);

should be a function

assert(typeof framework.throwsError === 'function', 'Expected framework.throwsError to be a function, not: '+(typeof framework.throwsError));

.values

should be truthy

assert(framework.values, 'Expected framework.values to be truthy, not: '+framework.values);

should be an object

assert(typeof framework.values === 'object', 'Expected framework.values to be an object, not: '+(typeof framework.values));

.invalidParamList

should be truthy

assert(framework.values.invalidParamList, 'Expected framework.values.invalidParamList to be truthy, not: '+framework.values.invalidParamList);

should be an object

assert(typeof framework.values.invalidParamList === 'object', 'Expected framework.values.invalidParamList to be an object, not: '+(typeof framework.values.invalidParamList));

.instanceMethodTests

should be truthy

assert(framework.instanceMethodTests, 'Expected framework.instanceMethodTests to be truthy, not: ' + framework.instanceMethodTests);

should be a function

assert(typeof framework.instanceMethodTests === 'function', 'Expected framework.instanceMethodTests to be a function, not: ' + (typeof framework.instanceMethodTests));

.boxView

should be truthy

assert(framework.boxView, 'Expected framework.boxView to be truthy, not: '+framework.boxView);

should be an object

assert(typeof framework.boxView === 'object', 'Expected framework.boxView to be an object, not: '+(typeof framework.boxView));

.validApiKey

should be a string

assert(typeof framework.boxView.validApiKey === 'string', 'Expected framework.boxView.validApiKey to be a string, not: '+(typeof framework.boxView.validApiKey));

should be non blank

assert(typeof framework.boxView.validApiKey === 'string' && framework.boxView.validApiKey.length > 0, 'Expected framework.boxView.validApiKey to be non-blank');

.dummyApiKey

should be a string

assert(typeof framework.boxView.dummyApiKey === 'string', 'Expected framework.boxView.dummyApiKey to be a string, not: ' + (typeof framework.boxView.dummyApiKey));

should be non blank

assert(typeof framework.boxView.dummyApiKey === 'string' && framework.boxView.validApiKey.length > 0, 'Expected framework.boxView.dummyApiKey to be non-blank');

Box View API: NodeJS API: base

constructor

should throw an error with no API Key

framework.throwsError(function(){new API();});

should throw an error if too many args are passed

framework.throwsError(function(){new API(framework.boxView.dummyApiKey, 1);});

should throw errors with invalid API Token parameters

framework.values.invalidParamList.forEach(function(e) {
  framework.throwsError(function() {
    new API(e.value);
  }, 'Expected an error with an API Token of type '+e.name);
});

should NOT throw an error with a non-empty API Key string

new API(framework.boxView.dummyApiKey);

instance

should have a uriString function

framework.assert(typeof instance.uriString === 'function');

should have a post function

framework.assert(typeof instance.post === 'function');

should have a put function

framework.assert(typeof instance.put === 'function');

should have a get function

framework.assert(typeof instance.get === 'function');

should have a del function

framework.assert(typeof instance.del === 'function');

.uriString()

should throw errors with invalid resource parameters

framework.values.invalidParamList.forEach(function(e) {
  framework.throwsError(function() {
    instance.uriString(e.value);
  }, 'Expected an error with a resource param of type '+e.name);
});

should create the correct uri for a resource (https://view-api.box.com/1/some/resource)

framework.assert(uriResource === uriBase, 'URI is not correct URI base: '+uriResource);

should create a uri from a querystring which starts with the resource URI (https://view-api.box.com/1/some/resource)

framework.assert(uriFromQS.indexOf(uriBase) === 0, 'URI does not start with resource URI: '+uriFromQS);

should create a uri from a query hash which starts with the resource URI (https://view-api.box.com/1/some/resource)

framework.assert(uriFromQuery.indexOf(uriBase) === 0, 'URI does not start with resource URI: '+uriFromQuery);

.post()

should not throw an error when called with a non-blank string resource, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string resource, an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a callback only

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, no options, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, a callback, and a extra parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, non-object options, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.put()

should not throw an error when called with a non-blank string resource, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string resource, an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a callback only

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, no options, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, a callback, and a extra parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, non-object options, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.get()

should not throw an error when called with a non-blank string resource, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string resource, an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a callback only

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, no options, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, a callback, and a extra parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, non-object options, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.del()

should not throw an error when called with a non-blank string resource, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string resource, an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a callback only

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, no options, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, a callback, and a extra parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string resource, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, non-object options, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string resource, an options hash, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

Box View API: NodeJS API: document

constructor

should throw an error with no API Token

framework.throwsError(function() {
  new API();
});

should throw an error if too many params are passed

framework.throwsError(function() {
  new API(framework.boxView.dummyApiKey, 1);
});

should throw an error with a undefined param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a null param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a number param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a boolean, true param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a boolean, false param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a object param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a function param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a empty array param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a empty string param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should NOT throw an error with a non-empty API Token string

new API(framework.boxView.dummyApiKey);

instance

should have an uploadUrl function

framework.assert(typeof instance.uploadUrl === 'function');

should have a list function

framework.assert(typeof instance.list === 'function');

should have an info function

framework.assert(typeof instance.info === 'function');

should have a changeName function

framework.assert(typeof instance.changeName === 'function');

should have a download function

framework.assert(typeof instance.download === 'function');

should have a remove function

framework.assert(typeof instance.remove === 'function');

should have a poll function

framework.assert(typeof instance.poll === 'function');

.uploadUrl()

should not throw an error when called with non-blank string url and filename parameters, and function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a single string parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a single function parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with non-blank string url and filename parameters, and no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a string parameter and a function parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string url parameter, a non-blank string filename parameter and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string url parameter, a blank string filename parameter and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with non-blank string url and filename parameters, and a non-function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with non-blank string url and filename parameters, a function callback, and some other parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.list()

should not throw an error when called with a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a single non-function parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-object options parameter, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with an options hash, a function callback, and another parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.info()

should not throw an error when called with a non-blank string document id, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string document id, a non-blank string of fields, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string document id, an array of field names, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string document id, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-string / non-array field names, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-blank string of field names, a function callback, and some additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.changeName()

should not throw an error when called with a non-blank string document id, a non-blank string name, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-blank string name, and a no function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-blank string name, and a non- function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id, a non-blank string name, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string document id, a non-blank string name, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a blank string name, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-string name, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with non-blank string document id and name, a function callback, and some additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.download()

should not throw an error when called with a non-blank string document id, a pdf download type, a write stream, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string document id, a zip download type, a write stream, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a non-zip / non-pdf download type, a write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, no write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, no write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, a non write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, a non write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, no write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, no write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, a write stream, and no function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, a write stream, and no function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, a write stream, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, a write stream, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id, a pdf download type, a write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id, a zip download type, a write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non string document id, a pdf download type, a write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non string document id, a zip download type, a write stream, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a pdf download type, a write stream, a function callback, and an additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a zip download type, a write stream, a function callback, and an additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.remove()

should not throw an error when called with a non-blank string document id and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id and no function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id and a non-function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string document id and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a function callback, and an additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

.poll()

should not throw an error when called with a non-blank string document id and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id and no function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id and a non-function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string document id and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, a function callback, and an additional parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

Box View API: NodeJS API: session

constructor

should throw an error with no API Token

framework.throwsError(function() {
  new API();
});

should throw an error if too many params are passed

framework.throwsError(function() {
  new API(framework.boxView.dummyApiKey, 1);
});

should throw an error with a undefined param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a null param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a number param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a boolean, true param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a boolean, false param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a object param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a function param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a empty array param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should throw an error with a empty string param

framework.throwsError(function() {
  new API(framework.values.invalidParamList[k].value);
});

should NOT throw an error with a non-empty API Token string

new API(framework.boxView.dummyApiKey);

instance

should have a create function

framework.assert(typeof instance.create === 'function');

.create()

should not throw an error when called with a non-blank string document id, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should not throw an error when called with a non-blank string document id, an options hash, and a function callback

getInstance()[method].apply(getInstance(), goodParams[i].args);

should throw an error when called with no parameters

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a callback only

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, no options, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, an options hash, no callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, an options hash, a callback, and a extra parameter

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a blank string document id, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-string document id, an options hash, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, non-object options, and a function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

should throw an error when called with a non-blank string document id, an options hash, and a non function callback

framework.throwsError(function () {
  getInstance()[method].apply(getInstance(), badParams[i].args);
});

Box View API: REST: document

should preload a file without timing out

var url = 'http://web.crocodoc.com/files/test-simple.pdf';
var name = url;
this.timeout(pollTimeout);
framework.tempUuid.fromUrl(url, name, function(e, r, b) {
  framework.assert(typeof b === 'object', 'Could not pre-load a document for the tests: e: '+ e +', typeof body: '+ typeof b + ' body: '+ framework.inspect(b, true, 1) );
  preloadedUuid = b.id;
  framework.tempUuid.waitFor(preloadedUuid, function(e, r, b) {
    done();
  });
});

.list()

should respond without timing out

this.timeout(responseTimeout);
instance.list(function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 200 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "document_collection", which is an object with more properties

expect(_ofn()).to.have.a.property(_pn);
expect(_ofn()[_pn]).to.be.an('object');

.document_collection

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "total_count"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "entries"

expect(_ofn()).to.have.a.property(_pn);

.total_count

should be of type "number"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.entries

should be of type "array"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.info()

with a non-existent document id

should respond without timing out

this.timeout(responseTimeout);
instance.info('non-existent docId', function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 404 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "detail"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.detail

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "Not found"

expect(_ofn()[_pn]).to.equal(_v);

with the id of a preloaded file

should respond without timing out

this.timeout(responseTimeout);
instance.info(preloadedUuid, function(e, r, b) {
  error = e;
  response = r;
  body = b;

  done();
});

should get a 200 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "type"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "id"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "status"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "name"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "created_at"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "modified_at"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.type

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "document"

expect(_ofn()[_pn]).to.equal(_v);

.id

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.status

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "done"

expect(_ofn()[_pn]).to.equal(_v);

.name

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.created_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.modified_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.uploadUrl()

with a malformed url

should respond without timing out

this.timeout(responseTimeout);
instance.uploadUrl('not a url', 'not a url', function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 400 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "url"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.url

should be of type "array"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

with a good url

should respond without timing out

this.timeout(responseTimeout);
instance.uploadUrl(url, name, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 202 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "type"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "id"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "status"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "name"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "created_at"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "modified_at"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.id should be non-blank

framework.assert(typeof body.id === 'string' && body.id.length > 0, 'Expected body.id to be a non-empty string, not: ('+typeof body.id+'): '+body.id);
uuid = body.id;
framework.tempUuid.add(uuid);

.type

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "document"

expect(_ofn()[_pn]).to.equal(_v);

.id

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.status

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.name

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.created_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.modified_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

the final retrieved status

should poll for a final response without timing out

this.timeout(pollTimeout);
instance.poll(uuid, function(e, r, b) {
  _fe = e;
  _fr = r;
  _fb = b;
  done();
});

should get a 200 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "type"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "id"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "status"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "name"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "created_at"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "modified_at"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.type

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "document"

expect(_ofn()[_pn]).to.equal(_v);

.id

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.status

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "done"

expect(_ofn()[_pn]).to.equal(_v);

.name

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.created_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.modified_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.download() as a zip

with a non-existent document id

should respond without timing out

this.timeout(responseTimeout);
instance.download('non-existent docId', API.downloadTypes.zip, outputStream, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 404 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/zip

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "body"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.body

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "detail"

expect(_ofn()[_pn]).to.equal(_v);

the downloaded file

should exist

framework.assert(fsUtils.isFile(outputFilename), 'Expected '+outputFilename+' to be a regular file');

should have zero length

framework.assert(fsUtils.fileSize(outputFilename) === 0, 'Expected '+outputFilename+' to be zero length');

with the id of a preloaded file

should respond without timing out

this.timeout(responseTimeout);
instance.download(preloadedUuid, API.downloadTypes.zip, outputStream, function(e, r, b) {
    error = e;
    response = r;
    body = b;
    done();
});

should get a 200 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/zip

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have no properties

expect(Object.keys(objFn()).length).to.equal(0);

the downloaded file

should exist

framework.assert(fsUtils.isFile(outputFilename), 'Expected '+outputFilename+' to be a regular file');

should not be zero length

framework.assert(fsUtils.fileSize(outputFilename) > 0, 'Expected '+outputFilename+' not to be zero length');

.download() as a pdf

with a non-existent document id

should respond without timing out

this.timeout(responseTimeout);
instance.download('non-existent docId', API.downloadTypes.pdf, outputStream, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 404 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/pdf

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "body"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.body

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "detail"

expect(_ofn()[_pn]).to.equal(_v);

the downloaded file

should exist

framework.assert(fsUtils.isFile(outputFilename), 'Expected '+outputFilename+' to be a regular file');

should have zero length

framework.assert(fsUtils.fileSize(outputFilename) === 0, 'Expected '+outputFilename+' to be zero length');

with the id of a preloaded file

should respond without timing out

this.timeout(responseTimeout);
instance.download(preloadedUuid, API.downloadTypes.pdf, outputStream, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 200 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/pdf

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have no properties

expect(Object.keys(objFn()).length).to.equal(0);

the downloaded file

should exist

framework.assert(fsUtils.isFile(outputFilename), 'Expected '+outputFilename+' to be a regular file');

should not be zero length

framework.assert(fsUtils.fileSize(outputFilename) > 0, 'Expected '+outputFilename+' not to be zero length');

.remove()

with a non-existent id

should respond without timing out

this.timeout(responseTimeout);
instance.remove('non-existent docId', function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 404 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "detail"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.detail

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "Not found"

expect(_ofn()[_pn]).to.equal(_v);

with a docId of a pre-loaded document

should respond without timing out

this.timeout(responseTimeout);
instance.remove(preloadedUuid, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 204 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should not have a property called "body"

expect(_ofn()).to.not.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

Box View API: REST: session

should preload a file without timing out

var url = 'http://web.crocodoc.com/files/test-simple.pdf';
var name = url;

this.timeout(pollTimeout);
framework.tempUuid.fromUrl(url, name, function(e, r, b) {
  framework.assert(typeof b === 'object', 'Could not pre-load a document for the tests: e: ' + e + ', typeof body: ' + typeof b + ' body: ' + framework.inspect(b, true, 1));
  preloadedUuid = b.id;
  framework.tempUuid.waitFor(preloadedUuid, function (e, r, b) {
    done();
  });
});

.create()

with an id for a preloaded file

should respond without timing out

this.timeout(responseTimeout);
instance.create(preloadedUuid, function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 201 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "type"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "id"

expect(_ofn()).to.have.a.property(_pn);

should have a property called "expires_at"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.type

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "session"

expect(_ofn()[_pn]).to.equal(_v);

.id

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

.expires_at

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

with malformed id

should respond without timing out

this.timeout(responseTimeout);
instance.create('maformed id', function (e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 400 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "document_id"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.document_id

should be of type "array"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

with a non-existent uuid

should respond without timing out

this.timeout(responseTimeout);
instance.create('non-existent docId xxxxxxxxxxxxx', function(e, r, b) {
  error = e;
  response = r;
  body = b;
  done();
});

should get a 404 response code

framework.assert(r().statusCode === statusCode, 'Expected status code to be ' + statusCode + ', not ' + r().statusCode);

should get a truthy response

framework.assert(r(), 'Expected response to be truthy, not: '+r());

should have truthy response headers

framework.assert(r().headers, 'Expected response headers to be truthy, not: '+r().headers);

should have a truthy response body

framework.assert(b(), 'Expected body to be truthy, not: '+b());

should get a falsey error

framework.assert(!e(), 'Expected error to be falsey, not: ' + e());

should have a content-type response header of application/json

var contentType = r().headers['content-type'];
framework.assert((typeof contentType === 'string') && contentType.toLowerCase().indexOf(mimeType) >= 0, 'Expected content type to be ' + mimeType + ', not: ' + contentType);

the response body

should be an object

expect(_ofn()).to.be.an('object');

should have a property called "detail"

expect(_ofn()).to.have.a.property(_pn);

should have no other properties

expect(objFn()).to.have.keys(keys);

.detail

should be of type "string"

if (_t.indexOf('?') === 0) {
  _t = _t.substring(1);
  if (_ofn()[_pn] === null) {
    // it's ok for something to be null if it's type string starts with a '?'
    return;
  }
}
expect(_ofn()[_pn]).to.be.a(_t);

should be equal to "Not found"

expect(_ofn()[_pn]).to.equal(_v);

Passed

414

Failed

Pending

Suites

108

Duration

23.642 ms

Total

414

Box View API: Tests Results

Box View API: Test framework tests

.assert

.url

.path

.qs

.inspect

.exec

.throwsError

.values

.invalidParamList

.instanceMethodTests

.boxView

.validApiKey

.dummyApiKey

Box View API: NodeJS API: base

constructor

instance

.uriString()

.post()

.put()

.get()

.del()

Box View API: NodeJS API: document

constructor

instance

.uploadUrl()

.list()

.info()

.changeName()

.download()

.remove()

.poll()

Box View API: NodeJS API: session

constructor

instance

.create()

Box View API: REST: document

.list()

the response body

.document_collection

.total_count

.entries

.info()

with a non-existent document id

the response body

.detail

with the id of a preloaded file

the response body

.type

.id

.status

.name

.created_at

.modified_at

.uploadUrl()

with a malformed url

the response body

.url

with a good url

the response body

.type

.id

.status

.name

.created_at

.modified_at

the final retrieved status

.type

.id

.status

.name

.created_at

.modified_at

.download() as a zip

with a non-existent document id

the response body

.body

the downloaded file

with the id of a preloaded file